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

package/src/session-props.ts

@@ -1,114 +0,0 @@
-/* Store some session-level attribution-related properties in the persistence layer
- *
- * These have the same lifespan as a session_id, meaning that if the session_id changes, these properties will be reset.
- *
- * We only store the entry URL and referrer, and derive many props (such as utm tags) from those.
- *
- * Given that the cookie is limited to 4K bytes, we don't want to store too much data, so we chose not to store device
- * properties (such as browser, OS, etc) here, as usually getting the current value of those from event properties is
- * sufficient.
- */
-import { getPersonInfo, getPersonPropsFromInfo } from './utils/event-utils'
-import type { SessionIdManager } from './sessionid'
-import type { LeanbasePersistence } from './leanbase-persistence'
-import { CLIENT_SESSION_PROPS } from './constants'
-import type { Leanbase } from './leanbase'
-import { each, stripEmptyProperties } from './utils'
-import { stripLeadingDollar } from '@posthog/core'
-
-interface LegacySessionSourceProps {
-    initialPathName: string
-    referringDomain: string // Is actually referring host, but named referring domain for internal consistency. Should contain a port if there is one.
-    utm_medium?: string
-    utm_source?: string
-    utm_campaign?: string
-    utm_content?: string
-    utm_term?: string
-}
-
-interface CurrentSessionSourceProps {
-    r: string // Referring host
-    u: string | undefined // full URL
-}
-
-interface StoredSessionSourceProps {
-    sessionId: string
-    props: LegacySessionSourceProps | CurrentSessionSourceProps
-}
-
-const generateSessionSourceParams = (posthog?: Leanbase): LegacySessionSourceProps | CurrentSessionSourceProps => {
-    return getPersonInfo(posthog?.config.mask_personal_data_properties, posthog?.config.custom_personal_data_properties)
-}
-
-export class SessionPropsManager {
-    private readonly _instance: Leanbase
-    private readonly _sessionIdManager: SessionIdManager
-    private readonly _persistence: LeanbasePersistence
-    private readonly _sessionSourceParamGenerator: (
-        instance?: Leanbase
-    ) => LegacySessionSourceProps | CurrentSessionSourceProps
-
-    constructor(
-        instance: Leanbase,
-        sessionIdManager: SessionIdManager,
-        persistence: LeanbasePersistence,
-        sessionSourceParamGenerator?: (instance?: Leanbase) => LegacySessionSourceProps | CurrentSessionSourceProps
-    ) {
-        this._instance = instance
-        this._sessionIdManager = sessionIdManager
-        this._persistence = persistence
-        this._sessionSourceParamGenerator = sessionSourceParamGenerator || generateSessionSourceParams
-
-        this._sessionIdManager.onSessionId(this._onSessionIdCallback)
-    }
-
-    _getStored(): StoredSessionSourceProps | undefined {
-        return this._persistence.props[CLIENT_SESSION_PROPS]
-    }
-
-    _onSessionIdCallback = (sessionId: string) => {
-        const stored = this._getStored()
-        if (stored && stored.sessionId === sessionId) {
-            return
-        }
-
-        const newProps: StoredSessionSourceProps = {
-            sessionId,
-            props: this._sessionSourceParamGenerator(this._instance),
-        }
-        this._persistence.register({ [CLIENT_SESSION_PROPS]: newProps })
-    }
-
-    getSetOnceProps() {
-        const p = this._getStored()?.props
-        if (!p) {
-            return {}
-        }
-        if ('r' in p) {
-            return getPersonPropsFromInfo(p)
-        } else {
-            return {
-                $referring_domain: p.referringDomain,
-                $pathname: p.initialPathName,
-                utm_source: p.utm_source,
-                utm_campaign: p.utm_campaign,
-                utm_medium: p.utm_medium,
-                utm_content: p.utm_content,
-                utm_term: p.utm_term,
-            }
-        }
-    }
-
-    getSessionProps() {
-        // it's the same props, but don't include null for unset properties, and add a prefix
-        const p: Record<string, any> = {}
-        each(stripEmptyProperties(this.getSetOnceProps()), (v, k) => {
-            if (k === '$current_url') {
-                // $session_entry_current_url would be a weird name, call it $session_entry_url instead
-                k = 'url'
-            }
-            p[`$session_entry_${stripLeadingDollar(k)}`] = v
-        })
-        return p
-    }
-}

package/src/utils/event-utils.ts

@@ -1,304 +0,0 @@
-import { convertToURL, getQueryParam, maskQueryParams } from './request-utils'
-import { isNull, stripLeadingDollar } from '@posthog/core'
-import { each, extend, extendArray, stripEmptyProperties } from './index'
-import { document, location, userAgent, window } from './'
-import { detectBrowser, detectBrowserVersion, detectDevice, detectDeviceType, detectOS } from './user-agent-utils'
-import { cookieStore } from '../storage'
-import Config from '../config'
-import { Properties } from '../types'
-
-const URL_REGEX_PREFIX = 'https?://(.*)'
-
-// CAMPAIGN_PARAMS and EVENT_TO_PERSON_PROPERTIES should be kept in sync with
-// https://github.com/PostHog/posthog/blob/master/plugin-server/src/utils/db/utils.ts#L60
-
-// The list of campaign parameters that could be considered personal data under e.g. GDPR.
-// These can be masked in URLs and properties before being sent to posthog.
-export const PERSONAL_DATA_CAMPAIGN_PARAMS = [
-    'gclid', // google ads
-    'gclsrc', // google ads 360
-    'dclid', // google display ads
-    'gbraid', // google ads, web to app
-    'wbraid', // google ads, app to web
-    'fbclid', // facebook
-    'msclkid', // microsoft
-    'twclid', // twitter
-    'li_fat_id', // linkedin
-    'igshid', // instagram
-    'ttclid', // tiktok
-    'rdt_cid', // reddit
-    'epik', // pinterest
-    'qclid', // quora
-    'sccid', // snapchat
-    'irclid', // impact
-    '_kx', // klaviyo
-]
-
-export const CAMPAIGN_PARAMS = extendArray(
-    [
-        'utm_source',
-        'utm_medium',
-        'utm_campaign',
-        'utm_content',
-        'utm_term',
-        'gad_source', // google ads source
-        'mc_cid', // mailchimp campaign id
-    ],
-    PERSONAL_DATA_CAMPAIGN_PARAMS
-)
-
-export const EVENT_TO_PERSON_PROPERTIES = [
-    // mobile params
-    '$app_build',
-    '$app_name',
-    '$app_namespace',
-    '$app_version',
-    // web params
-    '$browser',
-    '$browser_version',
-    '$device_type',
-    '$current_url',
-    '$pathname',
-    '$os',
-    '$os_name', // $os_name is a special case, it's treated as an alias of $os!
-    '$os_version',
-    '$referring_domain',
-    '$referrer',
-    '$screen_height',
-    '$screen_width',
-    '$viewport_height',
-    '$viewport_width',
-    '$raw_user_agent',
-]
-
-export const MASKED = '<masked>'
-
-// Campaign params that can be read from the cookie store
-export const COOKIE_CAMPAIGN_PARAMS = [
-    'li_fat_id', // linkedin
-]
-
-export function getCampaignParams(
-    customTrackedParams?: string[],
-    maskPersonalDataProperties?: boolean,
-    customPersonalDataProperties?: string[] | undefined
-): Record<string, string> {
-    if (!document) {
-        return {}
-    }
-
-    const paramsToMask = maskPersonalDataProperties
-        ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || [])
-        : []
-
-    // Initially get campaign params from the URL
-    const urlCampaignParams = _getCampaignParamsFromUrl(
-        maskQueryParams(document.URL, paramsToMask, MASKED),
-        customTrackedParams
-    )
-
-    // But we can also get some of them from the cookie store
-    // For example: https://learn.microsoft.com/en-us/linkedin/marketing/conversions/enabling-first-party-cookies?view=li-lms-2025-05#reading-li_fat_id-from-cookies
-    const cookieCampaignParams = _getCampaignParamsFromCookie()
-
-    // Prefer the values found in the urlCampaignParams if possible
-    // `extend` will override the values if found in the second argument
-    return extend(cookieCampaignParams, urlCampaignParams)
-}
-
-function _getCampaignParamsFromUrl(url: string, customParams?: string[]): Record<string, string> {
-    const campaign_keywords = CAMPAIGN_PARAMS.concat(customParams || [])
-
-    const params: Record<string, any> = {}
-    each(campaign_keywords, function (kwkey) {
-        const kw = getQueryParam(url, kwkey)
-        params[kwkey] = kw ? kw : null
-    })
-
-    return params
-}
-
-function _getCampaignParamsFromCookie(): Record<string, string> {
-    const params: Record<string, any> = {}
-    each(COOKIE_CAMPAIGN_PARAMS, function (kwkey) {
-        const kw = cookieStore._get(kwkey)
-        params[kwkey] = kw ? kw : null
-    })
-
-    return params
-}
-
-function _getSearchEngine(referrer: string): string | null {
-    if (!referrer) {
-        return null
-    } else {
-        if (referrer.search(URL_REGEX_PREFIX + 'google.([^/?]*)') === 0) {
-            return 'google'
-        } else if (referrer.search(URL_REGEX_PREFIX + 'bing.com') === 0) {
-            return 'bing'
-        } else if (referrer.search(URL_REGEX_PREFIX + 'yahoo.com') === 0) {
-            return 'yahoo'
-        } else if (referrer.search(URL_REGEX_PREFIX + 'duckduckgo.com') === 0) {
-            return 'duckduckgo'
-        } else {
-            return null
-        }
-    }
-}
-
-function _getSearchInfoFromReferrer(referrer: string): Record<string, any> {
-    const search = _getSearchEngine(referrer)
-    const param = search != 'yahoo' ? 'q' : 'p'
-    const ret: Record<string, any> = {}
-
-    if (!isNull(search)) {
-        ret['$search_engine'] = search
-
-        const keyword = document ? getQueryParam(document.referrer, param) : ''
-        if (keyword.length) {
-            ret['ph_keyword'] = keyword
-        }
-    }
-
-    return ret
-}
-
-export function getSearchInfo(): Record<string, any> {
-    const referrer = document?.referrer
-    if (!referrer) {
-        return {}
-    }
-    return _getSearchInfoFromReferrer(referrer)
-}
-
-export function getBrowserLanguage(): string | undefined {
-    return (
-        navigator.language || // Any modern browser
-        (navigator as Record<string, any>).userLanguage // IE11
-    )
-}
-
-export function getBrowserLanguagePrefix(): string | undefined {
-    const lang = getBrowserLanguage()
-    return typeof lang === 'string' ? lang.split('-')[0] : undefined
-}
-
-export function getReferrer(): string {
-    return document?.referrer || '$direct'
-}
-
-export function getReferringDomain(): string {
-    if (!document?.referrer) {
-        return '$direct'
-    }
-    return convertToURL(document.referrer)?.host || '$direct'
-}
-
-export function getReferrerInfo(): Record<string, any> {
-    return {
-        $referrer: getReferrer(),
-        $referring_domain: getReferringDomain(),
-    }
-}
-
-export function getPersonInfo(maskPersonalDataProperties?: boolean, customPersonalDataProperties?: string[]) {
-    const paramsToMask = maskPersonalDataProperties
-        ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || [])
-        : []
-    const url = location?.href.substring(0, 1000)
-    // we're being a bit more economical with bytes here because this is stored in the cookie
-    return {
-        r: getReferrer().substring(0, 1000),
-        u: url ? maskQueryParams(url, paramsToMask, MASKED) : undefined,
-    }
-}
-
-export function getPersonPropsFromInfo(info: Record<string, any>): Record<string, any> {
-    const { r: referrer, u: url } = info
-    const referring_domain =
-        referrer == null ? undefined : referrer == '$direct' ? '$direct' : convertToURL(referrer)?.host
-
-    const props: Record<string, string | undefined> = {
-        $referrer: referrer,
-        $referring_domain: referring_domain,
-    }
-    if (url) {
-        props['$current_url'] = url
-        const location = convertToURL(url)
-        props['$host'] = location?.host
-        props['$pathname'] = location?.pathname
-        const campaignParams = _getCampaignParamsFromUrl(url)
-        extend(props, campaignParams)
-    }
-    if (referrer) {
-        const searchInfo = _getSearchInfoFromReferrer(referrer)
-        extend(props, searchInfo)
-    }
-    return props
-}
-
-export function getInitialPersonPropsFromInfo(info: Record<string, any>): Record<string, any> {
-    const personProps = getPersonPropsFromInfo(info)
-    const props: Record<string, any> = {}
-    each(personProps, function (val: any, key: string) {
-        props[`$initial_${stripLeadingDollar(key)}`] = val
-    })
-    return props
-}
-
-export function getTimezone(): string | undefined {
-    try {
-        return Intl.DateTimeFormat().resolvedOptions().timeZone
-    } catch {
-        return undefined
-    }
-}
-
-export function getTimezoneOffset(): number | undefined {
-    try {
-        return new Date().getTimezoneOffset()
-    } catch {
-        return undefined
-    }
-}
-
-export function getEventProperties(
-    maskPersonalDataProperties?: boolean,
-    customPersonalDataProperties?: string[]
-): Properties {
-    if (!userAgent) {
-        return {}
-    }
-    const paramsToMask = maskPersonalDataProperties
-        ? extendArray([], PERSONAL_DATA_CAMPAIGN_PARAMS, customPersonalDataProperties || [])
-        : []
-    const [os_name, os_version] = detectOS(userAgent)
-    return extend(
-        stripEmptyProperties({
-            $os: os_name,
-            $os_version: os_version,
-            $browser: detectBrowser(userAgent, navigator.vendor),
-            $device: detectDevice(userAgent),
-            $device_type: detectDeviceType(userAgent),
-            $timezone: getTimezone(),
-            $timezone_offset: getTimezoneOffset(),
-        }),
-        {
-            $current_url: maskQueryParams(location?.href, paramsToMask, MASKED),
-            $host: location?.host,
-            $pathname: location?.pathname,
-            $raw_user_agent: userAgent.length > 1000 ? userAgent.substring(0, 997) + '...' : userAgent,
-            $browser_version: detectBrowserVersion(userAgent, navigator.vendor),
-            $browser_language: getBrowserLanguage(),
-            $browser_language_prefix: getBrowserLanguagePrefix(),
-            $screen_height: window?.screen.height,
-            $screen_width: window?.screen.width,
-            $viewport_height: window?.innerHeight,
-            $viewport_width: window?.innerWidth,
-            $lib: 'web',
-            $lib_version: Config.LIB_VERSION,
-            $insert_id: Math.random().toString(36).substring(2, 10) + Math.random().toString(36).substring(2, 10),
-            $time: Date.now() / 1000, // epoch time in seconds
-        }
-    )
-}

package/src/utils/index.ts

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