@leanbase-giangnd/js 0.0.7 → 0.1.1

package/src/utils/globals.ts

@@ -1,239 +0,0 @@
-import type { PostHog } from '../posthog-core'
-import { SessionIdManager } from '../sessionid'
-import {
-    DeadClicksAutoCaptureConfig,
-    ExternalIntegrationKind,
-    Properties,
-    RemoteConfig,
-    SiteAppLoader,
-    SessionStartReason,
-} from '../types'
-// only importing types here, so won't affect the bundle
-// eslint-disable-next-line posthog-js/no-external-replay-imports
-import type { SessionRecordingStatus, TriggerType } from '../extensions/replay/external/triggerMatching'
-import { eventWithTime } from '../extensions/replay/types/rrweb-types'
-import { ErrorTracking } from '@posthog/core'
-
-/*
- * Global helpers to protect access to browser globals in a way that is safer for different targets
- * like DOM, SSR, Web workers etc.
- *
- * NOTE: Typically we want the "window" but globalThis works for both the typical browser context as
- * well as other contexts such as the web worker context. Window is still exported for any bits that explicitly require it.
- * If in doubt - export the global you need from this file and use that as an optional value. This way the code path is forced
- * to handle the case where the global is not available.
- */
-
-// eslint-disable-next-line no-restricted-globals
-const win: (Window & typeof globalThis) | undefined = typeof window !== 'undefined' ? window : undefined
-
-export type AssignableWindow = Window &
-    typeof globalThis & {
-        /*
-         * Main PostHog instance
-         */
-        posthog: any
-
-        /*
-         * This is our contract between (potentially) lazily loaded extensions and the SDK
-         */
-        __PosthogExtensions__?: PostHogExtensions
-
-        /**
-         * When loading remote config, we assign it to this global configuration
-         * for ease of sharing it with the rest of the SDK
-         */
-        _POSTHOG_REMOTE_CONFIG?: Record<
-            string,
-            {
-                config: RemoteConfig
-                siteApps: SiteAppLoader[]
-            }
-        >
-
-        /**
-         * If this is set on the window, our logger will log to the console
-         * for ease of debugging. Used for testing purposes only.
-         *
-         * @see {Config.DEBUG} from config.ts
-         */
-        POSTHOG_DEBUG: any
-
-        // Exposed by the browser
-        doNotTrack: any
-
-        // See entrypoints/customizations.full.ts
-        posthogCustomizations: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/exception-autocapture.ts
-         *
-         * @deprecated use `__PosthogExtensions__.errorWrappingFunctions` instead
-         */
-        posthogErrorWrappingFunctions: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/posthog-recorder.ts
-         *
-         * @deprecated use `__PosthogExtensions__.rrweb` instead
-         */
-        rrweb: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/posthog-recorder.ts
-         *
-         * @deprecated use `__PosthogExtensions__.rrwebConsoleRecord` instead
-         */
-        rrwebConsoleRecord: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/posthog-recorder.ts
-         *
-         * @deprecated use `__PosthogExtensions__.getRecordNetworkPlugin` instead
-         */
-        getRecordNetworkPlugin: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/web-vitals.ts
-         *
-         * @deprecated use `__PosthogExtensions__.postHogWebVitalsCallbacks` instead
-         */
-        postHogWebVitalsCallbacks: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/tracing-headers.ts
-         *
-         * @deprecated use `__PosthogExtensions__.postHogTracingHeadersPatchFns` instead
-         */
-        postHogTracingHeadersPatchFns: any
-
-        /**
-         * This is a legacy way to expose these functions, but we still need to support it for backwards compatibility
-         * Can be removed once we drop support for 1.161.1
-         *
-         * See entrypoints/surveys.ts
-         *
-         * @deprecated use `__PosthogExtensions__.generateSurveys` instead
-         */
-        extendPostHogWithSurveys: any
-
-        /*
-         * These are used to handle our toolbar state.
-         * @see {Toolbar} from extensions/toolbar.ts
-         */
-        ph_load_toolbar: any
-        ph_load_editor: any
-        ph_toolbar_state: any
-    } & Record<`__$$ph_site_app_${string}`, any>
-
-/**
- * This is our contract between (potentially) lazily loaded extensions and the SDK
- * changes to this interface can be breaking changes for users of the SDK
- */
-
-export type ExternalExtensionKind = 'intercom-integration' | 'crisp-chat-integration'
-
-export type PostHogExtensionKind =
-    | 'toolbar'
-    | 'exception-autocapture'
-    | 'web-vitals'
-    | 'recorder'
-    | 'lazy-recorder'
-    | 'tracing-headers'
-    | 'surveys'
-    | 'dead-clicks-autocapture'
-    | 'remote-config'
-    | ExternalExtensionKind
-
-export interface LazyLoadedSessionRecordingInterface {
-    start: (startReason?: SessionStartReason) => void
-    stop: () => void
-    sessionId: string
-    status: SessionRecordingStatus
-    onRRwebEmit: (rawEvent: eventWithTime) => void
-    log: (message: string, level: 'log' | 'warn' | 'error') => void
-    sdkDebugProperties: Properties
-    overrideLinkedFlag: () => void
-    overrideSampling: () => void
-    overrideTrigger: (triggerType: TriggerType) => void
-    isStarted: boolean
-    tryAddCustomEvent(tag: string, payload: any): boolean
-}
-
-export interface LazyLoadedDeadClicksAutocaptureInterface {
-    start: (observerTarget: Node) => void
-    stop: () => void
-}
-
-interface PostHogExtensions {
-    loadExternalDependency?: (
-        posthog: PostHog,
-        kind: PostHogExtensionKind,
-        callback: (error?: string | Event, event?: Event) => void
-    ) => void
-
-    loadSiteApp?: (posthog: PostHog, appUrl: string, callback: (error?: string | Event, event?: Event) => void) => void
-
-    errorWrappingFunctions?: {
-        wrapOnError: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
-        wrapUnhandledRejection: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
-        wrapConsoleError: (captureFn: (props: ErrorTracking.ErrorProperties) => void) => () => void
-    }
-    rrweb?: { record: any; version: string }
-    rrwebPlugins?: { getRecordConsolePlugin: any; getRecordNetworkPlugin?: any }
-    generateSurveys?: (posthog: PostHog, isSurveysEnabled: boolean) => any | undefined
-    postHogWebVitalsCallbacks?: {
-        onLCP: (metric: any) => void
-        onCLS: (metric: any) => void
-        onFCP: (metric: any) => void
-        onINP: (metric: any) => void
-    }
-    tracingHeadersPatchFns?: {
-        _patchFetch: (hostnames: string[], distinctId: string, sessionManager?: SessionIdManager) => () => void
-        _patchXHR: (hostnames: string[], distinctId: string, sessionManager?: SessionIdManager) => () => void
-    }
-    initDeadClicksAutocapture?: (
-        ph: PostHog,
-        config: DeadClicksAutoCaptureConfig
-    ) => LazyLoadedDeadClicksAutocaptureInterface
-    integrations?: {
-        [K in ExternalIntegrationKind]?: { start: (posthog: PostHog) => void; stop: () => void }
-    }
-    initSessionRecording?: (ph: PostHog) => LazyLoadedSessionRecordingInterface
-}
-
-const global: typeof globalThis | undefined = typeof globalThis !== 'undefined' ? globalThis : win
-
-export const ArrayProto = Array.prototype
-export const nativeForEach = ArrayProto.forEach
-export const nativeIndexOf = ArrayProto.indexOf
-
-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 const assignableWindow: AssignableWindow = win ?? ({} as any)
-
-export { win as window }

package/src/utils/request-router.ts

@@ -1,77 +0,0 @@
-import { PostHog } from '../posthog-core'
-
-export enum RequestRouterRegion {
-    US = 'us',
-    EU = 'eu',
-    CUSTOM = 'custom',
-}
-
-export type RequestRouterTarget = 'api' | 'ui' | 'assets'
-
-const ingestionDomain = 'i.posthog.com'
-
-export class RequestRouter {
-    instance: PostHog
-    private _regionCache: Record<string, RequestRouterRegion> = {}
-
-    constructor(instance: PostHog) {
-        this.instance = instance
-    }
-
-    get apiHost(): string {
-        const host = this.instance.config.api_host.trim().replace(/\/$/, '')
-        if (host === 'https://app.posthog.com') {
-            return 'https://us.i.posthog.com'
-        }
-        return host
-    }
-    get uiHost(): string | undefined {
-        let host = this.instance.config.ui_host?.replace(/\/$/, '')
-
-        if (!host) {
-            host = this.apiHost.replace(`.${ingestionDomain}`, '.posthog.com')
-        }
-
-        if (host === 'https://app.posthog.com') {
-            return 'https://us.posthog.com'
-        }
-
-        return host
-    }
-
-    get region(): RequestRouterRegion {
-        if (!this._regionCache[this.apiHost]) {
-            if (/https:\/\/(app|us|us-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {
-                this._regionCache[this.apiHost] = RequestRouterRegion.US
-            } else if (/https:\/\/(eu|eu-assets)(\\.i)?\\.posthog\\.com/i.test(this.apiHost)) {
-                this._regionCache[this.apiHost] = RequestRouterRegion.EU
-            } else {
-                this._regionCache[this.apiHost] = RequestRouterRegion.CUSTOM
-            }
-        }
-        return this._regionCache[this.apiHost]
-    }
-
-    endpointFor(target: RequestRouterTarget, path: string = ''): string {
-        if (path) {
-            path = path[0] === '/' ? path : `/${path}`
-        }
-
-        if (target === 'ui') {
-            return this.uiHost + path
-        }
-
-        if (this.region === RequestRouterRegion.CUSTOM) {
-            return this.apiHost + path
-        }
-
-        const suffix = ingestionDomain + path
-
-        switch (target) {
-            case 'assets':
-                return `https://${this.region}-assets.${suffix}`
-            case 'api':
-                return `https://${this.region}.${suffix}`
-        }
-    }
-}

package/src/utils/type-utils.ts

@@ -1,139 +0,0 @@
-import { knownUnsafeEditableEvent, KnownUnsafeEditableEvent } from '@posthog/core'
-import { includes } from '@posthog/core'
-
-// eslint-disable-next-line posthog-js/no-direct-array-check
-const nativeIsArray = Array.isArray
-const ObjProto = Object.prototype
-export const hasOwnProperty = ObjProto.hasOwnProperty
-const toString = ObjProto.toString
-
-export const isArray =
-    nativeIsArray ||
-    function (obj: any): obj is any[] {
-        return toString.call(obj) === '[object Array]'
-    }
-
-// from a comment on http://dbj.org/dbj/?p=286
-// fails on only one very rare and deliberate custom object:
-// let bomb = { toString : undefined, valueOf: function(o) { return "function BOMBA!"; }};
-export const isFunction = (x: unknown): x is (...args: any[]) => any => {
-    // eslint-disable-next-line posthog-js/no-direct-function-check
-    return typeof x === 'function'
-}
-
-export const isNativeFunction = (x: unknown): x is (...args: any[]) => any =>
-    isFunction(x) && x.toString().indexOf('[native code]') !== -1
-
-// Underscore Addons
-export const isObject = (x: unknown): x is Record<string, any> => {
-    // eslint-disable-next-line posthog-js/no-direct-object-check
-    return x === Object(x) && !isArray(x)
-}
-export const isEmptyObject = (x: unknown) => {
-    if (isObject(x)) {
-        for (const key in x) {
-            if (hasOwnProperty.call(x, key)) {
-                return false
-            }
-        }
-        return true
-    }
-    return false
-}
-export const isUndefined = (x: unknown): x is undefined => x === void 0
-
-export const isString = (x: unknown): x is string => {
-    // eslint-disable-next-line posthog-js/no-direct-string-check
-    return toString.call(x) == '[object String]'
-}
-
-export const isEmptyString = (x: unknown): boolean => isString(x) && x.trim().length === 0
-
-export const isNull = (x: unknown): x is null => {
-    // eslint-disable-next-line posthog-js/no-direct-null-check
-    return x === null
-}
-
-/*
-    sometimes you want to check if something is null or undefined
-    that's what this is for
- */
-export const isNullish = (x: unknown): x is null | undefined => isUndefined(x) || isNull(x)
-
-export const isNumber = (x: unknown): x is number => {
-    // eslint-disable-next-line posthog-js/no-direct-number-check
-    return toString.call(x) == '[object Number]'
-}
-export const isBoolean = (x: unknown): x is boolean => {
-    // eslint-disable-next-line posthog-js/no-direct-boolean-check
-    return toString.call(x) === '[object Boolean]'
-}
-
-export const isFormData = (x: unknown): x is FormData => {
-    // eslint-disable-next-line posthog-js/no-direct-form-data-check
-    return x instanceof FormData
-}
-
-export const isFile = (x: unknown): x is File => {
-    // eslint-disable-next-line posthog-js/no-direct-file-check
-    return x instanceof File
-}
-
-export const isPlainError = (x: unknown): x is Error => {
-    return x instanceof Error
-}
-
-export const isKnownUnsafeEditableEvent = (x: unknown): x is KnownUnsafeEditableEvent => {
-    return includes(knownUnsafeEditableEvent as unknown as string[], x)
-}
-
-export function isInstanceOf(candidate: unknown, base: any): boolean {
-    try {
-        return candidate instanceof base
-    } catch {
-        return false
-    }
-}
-
-export function isPrimitive(value: unknown): boolean {
-    return isNull(value) || typeof value !== 'object'
-}
-
-export function isBuiltin(candidate: unknown, className: string): boolean {
-    return Object.prototype.toString.call(candidate) === `[object ${className}]`
-}
-
-export function isError(candidate: unknown): candidate is Error {
-    switch (Object.prototype.toString.call(candidate)) {
-        case '[object Error]':
-        case '[object Exception]':
-        case '[object DOMException]':
-        case '[object DOMError]':
-        case '[object WebAssembly.Exception]':
-            return true
-        default:
-            return isInstanceOf(candidate, Error)
-    }
-}
-
-export function isErrorEvent(event: unknown): boolean {
-    return isBuiltin(event, 'ErrorEvent')
-}
-
-export function isEvent(candidate: unknown): candidate is Event {
-    return !isUndefined(Event) && isInstanceOf(candidate, Event)
-}
-
-export const isDocument = (x: unknown): x is Document => {
-    // eslint-disable-next-line posthog-js/no-direct-document-check
-    return typeof Document !== 'undefined' && isInstanceOf(x, Document)
-}
-
-export function isPlainObject(candidate: unknown): candidate is Record<string, unknown> {
-    return isBuiltin(candidate, 'Object')
-}
-
-export const yesLikeValues = [true, 'true', 1, '1', 'yes']
-export const isYesLike = (val: string | boolean | number): boolean => includes(yesLikeValues, val)
-export const noLikeValues = [false, 'false', 0, '0', 'no']
-export const isNoLike = (val: string | boolean | number): boolean => includes(noLikeValues, val)