posthog-js-lite 3.4.1 → 3.5.0

package/lib/posthog-core/src/featureFlagUtils.d.ts

@@ -0,0 +1,34 @@
+import { FeatureFlagDetail, FeatureFlagValue, PostHogDecideResponse, PostHogV3DecideResponse, PostHogV4DecideResponse, PartialWithRequired, PostHogFeatureFlagsResponse } from './types';
+export declare const normalizeDecideResponse: (decideResponse: PartialWithRequired<PostHogV4DecideResponse, 'flags'> | PartialWithRequired<PostHogV3DecideResponse, 'featureFlags' | 'featureFlagPayloads'>) => PostHogFeatureFlagsResponse;
+/**
+ * Get the flag values from the flags v4 response.
+ * @param flags - The flags
+ * @returns The flag values
+ */
+export declare const getFlagValuesFromFlags: (flags: PostHogDecideResponse['flags']) => PostHogDecideResponse['featureFlags'];
+/**
+ * Get the payloads from the flags v4 response.
+ * @param flags - The flags
+ * @returns The payloads
+ */
+export declare const getPayloadsFromFlags: (flags: PostHogDecideResponse['flags']) => PostHogDecideResponse['featureFlagPayloads'];
+/**
+ * Get the flag details from the legacy v3 flags and payloads. As such, it will lack the reason, id, version, and description.
+ * @param decideResponse - The decide response
+ * @returns The flag details
+ */
+export declare const getFlagDetailsFromFlagsAndPayloads: (decideResponse: PostHogFeatureFlagsResponse) => PostHogDecideResponse['flags'];
+export declare const getFeatureFlagValue: (detail: FeatureFlagDetail | undefined) => FeatureFlagValue | undefined;
+export declare const parsePayload: (response: any) => any;
+/**
+ * Get the normalized flag details from the flags and payloads.
+ * This is used to convert things like boostrap and stored feature flags and payloads to the v4 format.
+ * This helps us ensure backwards compatibility.
+ * If a key exists in the featureFlagPayloads that is not in the featureFlags, we treat it as a true feature flag.
+ *
+ * @param featureFlags - The feature flags
+ * @param featureFlagPayloads - The feature flag payloads
+ * @returns The normalized flag details
+ */
+export declare const createDecideResponseFromFlagsAndPayloads: (featureFlags: PostHogV3DecideResponse['featureFlags'], featureFlagPayloads: PostHogV3DecideResponse['featureFlagPayloads']) => PostHogFeatureFlagsResponse;
+export declare const updateFlagValue: (flag: FeatureFlagDetail, value: FeatureFlagValue) => FeatureFlagDetail;

package/lib/posthog-core/src/index.d.ts

@@ -1,18 +1,21 @@
-import { PostHogFetchOptions, PostHogFetchResponse, PostHogAutocaptureElement, PostHogDecideResponse, PostHogCoreOptions, PostHogEventProperties, PostHogPersistedProperty, PostHogCaptureOptions, JsonType } from './types';
+import { PostHogFetchOptions, PostHogFetchResponse, PostHogAutocaptureElement, PostHogDecideResponse, PostHogCoreOptions, PostHogEventProperties, PostHogPersistedProperty, PostHogCaptureOptions, JsonType, PostHogRemoteConfig, FeatureFlagValue, PostHogFeatureFlagDetails, FeatureFlagDetail, SurveyResponse } from './types';
 import { RetriableOptions } from './utils';
-export * as utils from './utils';
 import { LZString } from './lz-string';
 import { SimpleEventEmitter } from './eventemitter';
+export * as utils from './utils';
 export declare abstract class PostHogCoreStateless {
     readonly apiKey: string;
     readonly host: string;
     readonly flushAt: number;
+    readonly preloadFeatureFlags: boolean;
+    readonly disableSurveys: boolean;
     private maxBatchSize;
     private maxQueueSize;
     private flushInterval;
     private flushPromise;
     private requestTimeout;
     private featureFlagsRequestTimeoutMs;
+    private remoteConfigRequestTimeoutMs;
     private captureMode;
     private removeDebugCallback?;
     private disableGeoip;
@@ -25,6 +28,7 @@ export declare abstract class PostHogCoreStateless {
     protected _retryOptions: RetriableOptions;
     protected _initPromise: Promise<void>;
     protected _isInitialized: boolean;
+    protected _remoteConfigResponsePromise?: Promise<PostHogRemoteConfig | undefined>;
     abstract fetch(url: string, options: PostHogFetchOptions): Promise<PostHogFetchResponse>;
     abstract getLibraryId(): string;
     abstract getLibraryVersion(): string;
@@ -58,19 +62,36 @@ export declare abstract class PostHogCoreStateless {
      *** GROUPS
      ***/
     protected groupIdentifyStateless(groupType: string, groupKey: string | number, groupProperties?: PostHogEventProperties, options?: PostHogCaptureOptions, distinctId?: string, eventProperties?: PostHogEventProperties): void;
+    protected getRemoteConfig(): Promise<PostHogRemoteConfig | undefined>;
     /***
      *** FEATURE FLAGS
      ***/
     protected getDecide(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, extraPayload?: Record<string, any>): Promise<PostHogDecideResponse | undefined>;
-    protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<boolean | string | undefined>;
+    protected getFeatureFlagStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
+        response: FeatureFlagValue | undefined;
+        requestId: string | undefined;
+    }>;
+    protected getFeatureFlagDetailStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
+        response: FeatureFlagDetail | undefined;
+        requestId: string | undefined;
+    } | undefined>;
     protected getFeatureFlagPayloadStateless(key: string, distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<JsonType | undefined>;
-    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
-    protected _parsePayload(response: any): any;
-    protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
-    protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean): Promise<{
+    protected getFeatureFlagPayloadsStateless(distinctId: string, groups?: Record<string, string>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogDecideResponse['featureFlagPayloads'] | undefined>;
+    protected getFeatureFlagsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
+        flags: PostHogDecideResponse['featureFlags'] | undefined;
+        payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogDecideResponse['requestId'] | undefined;
+    }>;
+    protected getFeatureFlagsAndPayloadsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<{
         flags: PostHogDecideResponse['featureFlags'] | undefined;
         payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
+        requestId: PostHogDecideResponse['requestId'] | undefined;
     }>;
+    protected getFeatureFlagDetailsStateless(distinctId: string, groups?: Record<string, string | number>, personProperties?: Record<string, string>, groupProperties?: Record<string, Record<string, string>>, disableGeoip?: boolean, flagKeysToEvaluate?: string[]): Promise<PostHogFeatureFlagDetails | undefined>;
+    /***
+     *** SURVEYS
+     ***/
+    getSurveysStateless(): Promise<SurveyResponse['surveys']>;
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -162,26 +183,37 @@ export declare abstract class PostHogCore extends PostHogCoreStateless {
     groupProperties(properties: {
         [type: string]: Record<string, string>;
     }): void;
+    private remoteConfigAsync;
     /***
      *** FEATURE FLAGS
      ***/
     private decideAsync;
+    private cacheSessionReplay;
+    private _remoteConfigAsync;
     private _decideAsync;
-    private setKnownFeatureFlags;
-    private setKnownFeatureFlagPayloads;
-    getFeatureFlag(key: string): boolean | string | undefined;
+    private setKnownFeatureFlagDetails;
+    private getKnownFeatureFlagDetails;
+    private getKnownFeatureFlags;
+    private getKnownFeatureFlagPayloads;
+    private getBootstrappedFeatureFlagDetails;
+    private setBootstrappedFeatureFlagDetails;
+    private getBootstrappedFeatureFlags;
+    private getBootstrappedFeatureFlagPayloads;
+    getFeatureFlag(key: string): FeatureFlagValue | undefined;
     getFeatureFlagPayload(key: string): JsonType | undefined;
     getFeatureFlagPayloads(): PostHogDecideResponse['featureFlagPayloads'] | undefined;
     getFeatureFlags(): PostHogDecideResponse['featureFlags'] | undefined;
+    getFeatureFlagDetails(): PostHogFeatureFlagDetails | undefined;
     getFeatureFlagsAndPayloads(): {
         flags: PostHogDecideResponse['featureFlags'] | undefined;
         payloads: PostHogDecideResponse['featureFlagPayloads'] | undefined;
     };
     isFeatureEnabled(key: string): boolean | undefined;
     reloadFeatureFlags(cb?: (err?: Error, flags?: PostHogDecideResponse['featureFlags']) => void): void;
+    reloadRemoteConfigAsync(): Promise<PostHogRemoteConfig | undefined>;
     reloadFeatureFlagsAsync(sendAnonDistinctId?: boolean): Promise<PostHogDecideResponse['featureFlags'] | undefined>;
     onFeatureFlags(cb: (flags: PostHogDecideResponse['featureFlags']) => void): () => void;
-    onFeatureFlag(key: string, cb: (value: string | boolean) => void): () => void;
+    onFeatureFlag(key: string, cb: (value: FeatureFlagValue) => void): () => void;
     overrideFeatureFlag(flags: PostHogDecideResponse['featureFlags'] | null): Promise<void>;
     /***
      *** ERROR TRACKING

package/lib/posthog-core/src/patch.d.ts

@@ -0,0 +1,3 @@
+export declare function patch(source: {
+    [key: string]: any;
+}, name: string, replacement: (...args: unknown[]) => unknown): () => void;

package/lib/posthog-core/src/types.d.ts

@@ -19,11 +19,23 @@ export type PostHogCoreOptions = {
     sendFeatureFlagEvent?: boolean;
     /** Whether to load feature flags when initialized or not */
     preloadFeatureFlags?: boolean;
+    /**
+     * Whether to load remote config when initialized or not
+     * Experimental support
+     * Default: false - Remote config is loaded by default
+     */
+    disableRemoteConfig?: boolean;
+    /**
+     * Whether to load surveys when initialized or not
+     * Experimental support
+     * Default: false - Surveys are loaded by default, but requires the `PostHogSurveyProvider` to be used
+     */
+    disableSurveys?: boolean;
     /** Option to bootstrap the library with given distinctId and feature flags */
     bootstrap?: {
         distinctId?: string;
         isIdentifiedId?: boolean;
-        featureFlags?: Record<string, boolean | string>;
+        featureFlags?: Record<string, FeatureFlagValue>;
         featureFlagPayloads?: Record<string, JsonType>;
     };
     /** How many times we will retry HTTP requests. Defaults to 3. */
@@ -34,6 +46,8 @@ export type PostHogCoreOptions = {
     requestTimeout?: number;
     /** Timeout in milliseconds for feature flag calls. Defaults to 10 seconds for stateful clients, and 3 seconds for stateless. */
     featureFlagsRequestTimeoutMs?: number;
+    /** Timeout in milliseconds for remote config calls. Defaults to 3 seconds. */
+    remoteConfigRequestTimeoutMs?: number;
     /** For Session Analysis how long before we expire a session (defaults to 30 mins) */
     sessionExpirationTimeSeconds?: number;
     /** Whether to post events to PostHog in JSON or compressed format. Defaults to 'json' */
@@ -46,8 +60,10 @@ export declare enum PostHogPersistedProperty {
     AnonymousId = "anonymous_id",
     DistinctId = "distinct_id",
     Props = "props",
+    FeatureFlagDetails = "feature_flag_details",
     FeatureFlags = "feature_flags",
     FeatureFlagPayloads = "feature_flag_payloads",
+    BootstrapFeatureFlagDetails = "bootstrap_feature_flag_details",
     BootstrapFeatureFlags = "bootstrap_feature_flags",
     BootstrapFeatureFlagPayloads = "bootstrap_feature_flag_payloads",
     OverrideFeatureFlags = "override_feature_flags",
@@ -60,7 +76,11 @@ export declare enum PostHogPersistedProperty {
     InstalledAppBuild = "installed_app_build",
     InstalledAppVersion = "installed_app_version",
     SessionReplay = "session_replay",
-    DecideEndpointWasHit = "decide_endpoint_was_hit"
+    DecideEndpointWasHit = "decide_endpoint_was_hit",
+    SurveyLastSeenDate = "survey_last_seen_date",
+    SurveysSeen = "surveys_seen",
+    Surveys = "surveys",
+    RemoteConfig = "remote_config"
 }
 export type PostHogFetchOptions = {
     method: 'GET' | 'POST' | 'PUT' | 'PATCH';
@@ -101,32 +121,302 @@ export type PostHogAutocaptureElement = {
 } & {
     [key: string]: any;
 };
-export type PostHogDecideResponse = {
-    config: {
-        enable_collect_everything: boolean;
-    };
-    editorParams: {
-        toolbarVersion: string;
-        jsURL: string;
+export type PostHogRemoteConfig = {
+    sessionRecording?: boolean | {
+        [key: string]: JsonType;
     };
-    isAuthenticated: true;
-    supportedCompression: string[];
+    /**
+     * Whether surveys are enabled
+     */
+    surveys?: boolean | Survey[];
+    /**
+     * Indicates if the team has any flags enabled (if not we don't need to load them)
+     */
+    hasFeatureFlags?: boolean;
+};
+export type FeatureFlagValue = string | boolean;
+export type PostHogDecideResponse = Omit<PostHogRemoteConfig, 'surveys' | 'hasFeatureFlags'> & {
     featureFlags: {
-        [key: string]: string | boolean;
+        [key: string]: FeatureFlagValue;
     };
     featureFlagPayloads: {
         [key: string]: JsonType;
     };
+    flags: {
+        [key: string]: FeatureFlagDetail;
+    };
     errorsWhileComputingFlags: boolean;
     sessionRecording?: boolean | {
         [key: string]: JsonType;
     };
+    quotaLimited?: string[];
+    requestId?: string;
 };
-export type PostHogFlagsAndPayloadsResponse = {
-    featureFlags: PostHogDecideResponse['featureFlags'];
-    featureFlagPayloads: PostHogDecideResponse['featureFlagPayloads'];
+export type PostHogFeatureFlagsResponse = PartialWithRequired<PostHogDecideResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
+/**
+ * Creates a type with all properties of T, but makes only K properties required while the rest remain optional.
+ *
+ * @template T - The base type containing all properties
+ * @template K - Union type of keys from T that should be required
+ *
+ * @example
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email?: string;
+ *   age?: number;
+ * }
+ *
+ * // Makes 'id' and 'name' required, but 'email' and 'age' optional
+ * type RequiredUser = PartialWithRequired<User, 'id' | 'name'>;
+ *
+ * const user: RequiredUser = {
+ *   id: 1,      // Must be provided
+ *   name: "John" // Must be provided
+ *   // email and age are optional
+ * };
+ */
+export type PartialWithRequired<T, K extends keyof T> = {
+    [P in K]: T[P];
+} & {
+    [P in Exclude<keyof T, K>]?: T[P];
 };
+/**
+ * These are the fields we care about from PostHogDecideResponse for feature flags.
+ */
+export type PostHogFeatureFlagDetails = PartialWithRequired<PostHogDecideResponse, 'flags' | 'featureFlags' | 'featureFlagPayloads' | 'requestId'>;
+/**
+ * Models the response from the v3 `/decide` endpoint.
+ */
+export type PostHogV3DecideResponse = Omit<PostHogDecideResponse, 'flags'>;
+export type PostHogV4DecideResponse = Omit<PostHogDecideResponse, 'featureFlags' | 'featureFlagPayloads'>;
+/**
+ * The format of the flags object in persisted storage
+ *
+ * When we pull flags from persistence, we can normalize them to PostHogFeatureFlagDetails
+ * so that we can support v3 and v4 of the API.
+ */
+export type PostHogFlagsStorageFormat = Pick<PostHogFeatureFlagDetails, 'flags'>;
+/**
+ * Models legacy flags and payloads return type for many public methods.
+ */
+export type PostHogFlagsAndPayloadsResponse = Partial<Pick<PostHogDecideResponse, 'featureFlags' | 'featureFlagPayloads'>>;
 export type JsonType = string | number | boolean | null | {
     [key: string]: JsonType;
 } | Array<JsonType>;
 export type FetchLike = (url: string, options: PostHogFetchOptions) => Promise<PostHogFetchResponse>;
+export type FeatureFlagDetail = {
+    key: string;
+    enabled: boolean;
+    variant: string | undefined;
+    reason: EvaluationReason | undefined;
+    metadata: FeatureFlagMetadata | undefined;
+};
+export type FeatureFlagMetadata = {
+    id: number | undefined;
+    version: number | undefined;
+    description: string | undefined;
+    payload: string | undefined;
+};
+export type EvaluationReason = {
+    code: string | undefined;
+    condition_index: number | undefined;
+    description: string | undefined;
+};
+export type SurveyAppearance = {
+    backgroundColor?: string;
+    submitButtonColor?: string;
+    submitButtonText?: string;
+    submitButtonTextColor?: string;
+    ratingButtonColor?: string;
+    ratingButtonActiveColor?: string;
+    autoDisappear?: boolean;
+    displayThankYouMessage?: boolean;
+    thankYouMessageHeader?: string;
+    thankYouMessageDescription?: string;
+    thankYouMessageDescriptionContentType?: SurveyQuestionDescriptionContentType;
+    thankYouMessageCloseButtonText?: string;
+    borderColor?: string;
+    position?: SurveyPosition;
+    placeholder?: string;
+    shuffleQuestions?: boolean;
+    surveyPopupDelaySeconds?: number;
+    widgetType?: SurveyWidgetType;
+    widgetSelector?: string;
+    widgetLabel?: string;
+    widgetColor?: string;
+};
+export declare enum SurveyPosition {
+    Left = "left",
+    Right = "right",
+    Center = "center"
+}
+export declare enum SurveyWidgetType {
+    Button = "button",
+    Tab = "tab",
+    Selector = "selector"
+}
+export declare enum SurveyType {
+    Popover = "popover",
+    API = "api",
+    Widget = "widget"
+}
+export type SurveyQuestion = BasicSurveyQuestion | LinkSurveyQuestion | RatingSurveyQuestion | MultipleSurveyQuestion;
+export declare enum SurveyQuestionDescriptionContentType {
+    Html = "html",
+    Text = "text"
+}
+type SurveyQuestionBase = {
+    question: string;
+    id?: string;
+    description?: string;
+    descriptionContentType?: SurveyQuestionDescriptionContentType;
+    optional?: boolean;
+    buttonText?: string;
+    originalQuestionIndex: number;
+    branching?: NextQuestionBranching | EndBranching | ResponseBasedBranching | SpecificQuestionBranching;
+};
+export type BasicSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Open;
+};
+export type LinkSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Link;
+    link?: string;
+};
+export type RatingSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.Rating;
+    display: SurveyRatingDisplay;
+    scale: 3 | 5 | 7 | 10;
+    lowerBoundLabel: string;
+    upperBoundLabel: string;
+};
+export declare enum SurveyRatingDisplay {
+    Number = "number",
+    Emoji = "emoji"
+}
+export type MultipleSurveyQuestion = SurveyQuestionBase & {
+    type: SurveyQuestionType.SingleChoice | SurveyQuestionType.MultipleChoice;
+    choices: string[];
+    hasOpenChoice?: boolean;
+    shuffleOptions?: boolean;
+};
+export declare enum SurveyQuestionType {
+    Open = "open",
+    MultipleChoice = "multiple_choice",
+    SingleChoice = "single_choice",
+    Rating = "rating",
+    Link = "link"
+}
+export declare enum SurveyQuestionBranchingType {
+    NextQuestion = "next_question",
+    End = "end",
+    ResponseBased = "response_based",
+    SpecificQuestion = "specific_question"
+}
+export type NextQuestionBranching = {
+    type: SurveyQuestionBranchingType.NextQuestion;
+};
+export type EndBranching = {
+    type: SurveyQuestionBranchingType.End;
+};
+export type ResponseBasedBranching = {
+    type: SurveyQuestionBranchingType.ResponseBased;
+    responseValues: Record<string, any>;
+};
+export type SpecificQuestionBranching = {
+    type: SurveyQuestionBranchingType.SpecificQuestion;
+    index: number;
+};
+export type SurveyResponse = {
+    surveys: Survey[];
+};
+export type SurveyCallback = (surveys: Survey[]) => void;
+export declare enum SurveyMatchType {
+    Regex = "regex",
+    NotRegex = "not_regex",
+    Exact = "exact",
+    IsNot = "is_not",
+    Icontains = "icontains",
+    NotIcontains = "not_icontains"
+}
+export type SurveyElement = {
+    text?: string;
+    $el_text?: string;
+    tag_name?: string;
+    href?: string;
+    attr_id?: string;
+    attr_class?: string[];
+    nth_child?: number;
+    nth_of_type?: number;
+    attributes?: Record<string, any>;
+    event_id?: number;
+    order?: number;
+    group_id?: number;
+};
+export type SurveyRenderReason = {
+    visible: boolean;
+    disabledReason?: string;
+};
+export type Survey = {
+    id: string;
+    name: string;
+    description?: string;
+    type: SurveyType;
+    feature_flag_keys?: {
+        key: string;
+        value?: string;
+    }[];
+    linked_flag_key?: string;
+    targeting_flag_key?: string;
+    internal_targeting_flag_key?: string;
+    questions: SurveyQuestion[];
+    appearance?: SurveyAppearance;
+    conditions?: {
+        url?: string;
+        selector?: string;
+        seenSurveyWaitPeriodInDays?: number;
+        urlMatchType?: SurveyMatchType;
+        events?: {
+            repeatedActivation?: boolean;
+            values?: {
+                name: string;
+            }[];
+        };
+        actions?: {
+            values: SurveyActionType[];
+        };
+        deviceTypes?: string[];
+        deviceTypesMatchType?: SurveyMatchType;
+    };
+    start_date?: string;
+    end_date?: string;
+    current_iteration?: number;
+    current_iteration_start_date?: string;
+};
+export type SurveyActionType = {
+    id: number;
+    name?: string;
+    steps?: ActionStepType[];
+};
+/** Sync with plugin-server/src/types.ts */
+export declare enum ActionStepStringMatching {
+    Contains = "contains",
+    Exact = "exact",
+    Regex = "regex"
+}
+export type ActionStepType = {
+    event?: string;
+    selector?: string;
+    /** @deprecated Only `selector` should be used now. */
+    tag_name?: string;
+    text?: string;
+    /** @default StringMatching.Exact */
+    text_matching?: ActionStepStringMatching;
+    href?: string;
+    /** @default ActionStepStringMatching.Exact */
+    href_matching?: ActionStepStringMatching;
+    url?: string;
+    /** @default StringMatching.Contains */
+    url_matching?: ActionStepStringMatching;
+};
+export {};

package/lib/posthog-core/src/utils.d.ts

@@ -1,4 +1,6 @@
 import { FetchLike } from './types';
+export declare const NEW_FLAGS_ROLLOUT_PERCENTAGE = 1;
+export declare const NEW_FLAGS_EXCLUDED_HASHES: Set<string>;
 export declare function assert(truthyValue: any, message: string): void;
 export declare function removeTrailingSlash(url: string): string;
 export interface RetriableOptions {
@@ -13,3 +15,5 @@ export declare function safeSetTimeout(fn: () => void, timeout: number): any;
 export declare const isPromise: (obj: any) => obj is Promise<any>;
 export declare const isError: (x: unknown) => x is Error;
 export declare function getFetch(): FetchLike | undefined;
+export declare const isFunction: (f: any) => f is (...args: any[]) => any;
+export declare function isTokenInRollout(token: string, percentage?: number, excludedHashes?: Set<string>): boolean;

package/lib/posthog-web/src/posthog-web.d.ts

@@ -4,6 +4,7 @@ export declare class PostHog extends PostHogCore {
     private _storage;
     private _storageCache;
     private _storageKey;
+    private _lastPathname;
     constructor(apiKey: string, options?: PostHogOptions);
     private getWindow;
     getPersistedProperty<T>(key: PostHogPersistedProperty): T | undefined;
@@ -13,4 +14,6 @@ export declare class PostHog extends PostHogCore {
     getLibraryVersion(): string;
     getCustomUserAgent(): void;
     getCommonEventProperties(): any;
+    private setupHistoryEventTracking;
+    private captureNavigationEvent;
 }

package/lib/posthog-web/src/types.d.ts

@@ -3,4 +3,5 @@ export type PostHogOptions = {
     autocapture?: boolean;
     persistence?: 'localStorage' | 'sessionStorage' | 'cookie' | 'memory';
     persistence_name?: string;
+    captureHistoryEvents?: boolean;
 } & PostHogCoreOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "posthog-js-lite",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "main": "lib/index.cjs.js",
   "module": "lib/index.esm.js",
   "types": "lib/index.d.ts",

package/src/posthog-web.ts

@@ -9,11 +9,13 @@ import { PostHogStorage, getStorage } from './storage'
 import { version } from '../package.json'
 import { PostHogOptions } from './types'
 import { getFetch } from 'posthog-core/src/utils'
+import { patch } from '../../posthog-core/src/patch'
 
 export class PostHog extends PostHogCore {
   private _storage: PostHogStorage
   private _storageCache: any
   private _storageKey: string
+  private _lastPathname: string = ''
 
   constructor(apiKey: string, options?: PostHogOptions) {
     super(apiKey, options)
@@ -27,6 +29,11 @@ export class PostHog extends PostHogCore {
     if (options?.preloadFeatureFlags !== false) {
       this.reloadFeatureFlags()
     }
+
+    if (options?.captureHistoryEvents && typeof window !== 'undefined') {
+      this._lastPathname = window?.location?.pathname || ''
+      this.setupHistoryEventTracking()
+    }
   }
 
   private getWindow(): Window | undefined {
@@ -84,4 +91,49 @@ export class PostHog extends PostHogCore {
       ...getContext(this.getWindow()),
     }
   }
+
+  private setupHistoryEventTracking(): void {
+    const window = this.getWindow()
+    if (!window) {
+      return
+    }
+
+    // Old fashioned, we could also use arrow functions but I think the closure for a patch is more reliable
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const self = this
+
+    patch(window.history, 'pushState', (originalPushState) => {
+      return function patchedPushState(this: History, state: any, title: string, url?: string | URL | null): void {
+        ;(originalPushState as History['pushState']).call(this, state, title, url)
+        self.captureNavigationEvent('pushState')
+      }
+    })
+
+    patch(window.history, 'replaceState', (originalReplaceState) => {
+      return function patchedReplaceState(this: History, state: any, title: string, url?: string | URL | null): void {
+        ;(originalReplaceState as History['replaceState']).call(this, state, title, url)
+        self.captureNavigationEvent('replaceState')
+      }
+    })
+
+    // For popstate we need to listen to the event instead of overriding a method
+    window.addEventListener('popstate', () => {
+      this.captureNavigationEvent('popstate')
+    })
+  }
+
+  private captureNavigationEvent(navigationType: 'pushState' | 'replaceState' | 'popstate'): void {
+    const window = this.getWindow()
+    if (!window) {
+      return
+    }
+
+    const currentPathname = window.location.pathname
+
+    // Only capture pageview if the pathname has changed
+    if (currentPathname !== this._lastPathname) {
+      this.capture('$pageview', { navigation_type: navigationType })
+      this._lastPathname = currentPathname
+    }
+  }
 }

package/src/types.ts

@@ -4,4 +4,5 @@ export type PostHogOptions = {
   autocapture?: boolean
   persistence?: 'localStorage' | 'sessionStorage' | 'cookie' | 'memory'
   persistence_name?: string
+  captureHistoryEvents?: boolean
 } & PostHogCoreOptions