posthog-js-lite 3.4.1 → 3.5.0

package/lib/index.cjs.js

@@ -7,8 +7,10 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
     PostHogPersistedProperty["DistinctId"] = "distinct_id";
     PostHogPersistedProperty["Props"] = "props";
+    PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
     PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
     PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
+    PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
     PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
     PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
@@ -22,13 +24,284 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
     PostHogPersistedProperty["DecideEndpointWasHit"] = "decide_endpoint_was_hit";
-})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+    PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
+    PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
+    PostHogPersistedProperty["Surveys"] = "surveys";
+    PostHogPersistedProperty["RemoteConfig"] = "remote_config";
+})(PostHogPersistedProperty || (PostHogPersistedProperty = {}));
+var SurveyPosition;
+(function (SurveyPosition) {
+    SurveyPosition["Left"] = "left";
+    SurveyPosition["Right"] = "right";
+    SurveyPosition["Center"] = "center";
+})(SurveyPosition || (SurveyPosition = {}));
+var SurveyWidgetType;
+(function (SurveyWidgetType) {
+    SurveyWidgetType["Button"] = "button";
+    SurveyWidgetType["Tab"] = "tab";
+    SurveyWidgetType["Selector"] = "selector";
+})(SurveyWidgetType || (SurveyWidgetType = {}));
+var SurveyType;
+(function (SurveyType) {
+    SurveyType["Popover"] = "popover";
+    SurveyType["API"] = "api";
+    SurveyType["Widget"] = "widget";
+})(SurveyType || (SurveyType = {}));
+var SurveyQuestionDescriptionContentType;
+(function (SurveyQuestionDescriptionContentType) {
+    SurveyQuestionDescriptionContentType["Html"] = "html";
+    SurveyQuestionDescriptionContentType["Text"] = "text";
+})(SurveyQuestionDescriptionContentType || (SurveyQuestionDescriptionContentType = {}));
+var SurveyRatingDisplay;
+(function (SurveyRatingDisplay) {
+    SurveyRatingDisplay["Number"] = "number";
+    SurveyRatingDisplay["Emoji"] = "emoji";
+})(SurveyRatingDisplay || (SurveyRatingDisplay = {}));
+var SurveyQuestionType;
+(function (SurveyQuestionType) {
+    SurveyQuestionType["Open"] = "open";
+    SurveyQuestionType["MultipleChoice"] = "multiple_choice";
+    SurveyQuestionType["SingleChoice"] = "single_choice";
+    SurveyQuestionType["Rating"] = "rating";
+    SurveyQuestionType["Link"] = "link";
+})(SurveyQuestionType || (SurveyQuestionType = {}));
+var SurveyQuestionBranchingType;
+(function (SurveyQuestionBranchingType) {
+    SurveyQuestionBranchingType["NextQuestion"] = "next_question";
+    SurveyQuestionBranchingType["End"] = "end";
+    SurveyQuestionBranchingType["ResponseBased"] = "response_based";
+    SurveyQuestionBranchingType["SpecificQuestion"] = "specific_question";
+})(SurveyQuestionBranchingType || (SurveyQuestionBranchingType = {}));
+var SurveyMatchType;
+(function (SurveyMatchType) {
+    SurveyMatchType["Regex"] = "regex";
+    SurveyMatchType["NotRegex"] = "not_regex";
+    SurveyMatchType["Exact"] = "exact";
+    SurveyMatchType["IsNot"] = "is_not";
+    SurveyMatchType["Icontains"] = "icontains";
+    SurveyMatchType["NotIcontains"] = "not_icontains";
+})(SurveyMatchType || (SurveyMatchType = {}));
+/** Sync with plugin-server/src/types.ts */
+var ActionStepStringMatching;
+(function (ActionStepStringMatching) {
+    ActionStepStringMatching["Contains"] = "contains";
+    ActionStepStringMatching["Exact"] = "exact";
+    ActionStepStringMatching["Regex"] = "regex";
+})(ActionStepStringMatching || (ActionStepStringMatching = {}));
 
+const normalizeDecideResponse = (decideResponse) => {
+    if ('flags' in decideResponse) {
+        // Convert v4 format to v3 format
+        const featureFlags = getFlagValuesFromFlags(decideResponse.flags);
+        const featureFlagPayloads = getPayloadsFromFlags(decideResponse.flags);
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+        };
+    }
+    else {
+        // Convert v3 format to v4 format
+        const featureFlags = decideResponse.featureFlags ?? {};
+        const featureFlagPayloads = Object.fromEntries(Object.entries(decideResponse.featureFlagPayloads || {}).map(([k, v]) => [k, parsePayload(v)]));
+        const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
+            key,
+            getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key]),
+        ]));
+        return {
+            ...decideResponse,
+            featureFlags,
+            featureFlagPayloads,
+            flags,
+        };
+    }
+};
+function getFlagDetailFromFlagAndPayload(key, value, payload) {
+    return {
+        key: key,
+        enabled: typeof value === 'string' ? true : value,
+        variant: typeof value === 'string' ? value : undefined,
+        reason: undefined,
+        metadata: {
+            id: undefined,
+            version: undefined,
+            payload: payload ? JSON.stringify(payload) : undefined,
+            description: undefined,
+        },
+    };
+}
+/**
+ * Get the flag values from the flags v4 response.
+ * @param flags - The flags
+ * @returns The flag values
+ */
+const getFlagValuesFromFlags = (flags) => {
+    return Object.fromEntries(Object.entries(flags ?? {})
+        .map(([key, detail]) => [key, getFeatureFlagValue(detail)])
+        .filter(([, value]) => value !== undefined));
+};
+/**
+ * Get the payloads from the flags v4 response.
+ * @param flags - The flags
+ * @returns The payloads
+ */
+const getPayloadsFromFlags = (flags) => {
+    const safeFlags = flags ?? {};
+    return Object.fromEntries(Object.keys(safeFlags)
+        .filter((flag) => {
+        const details = safeFlags[flag];
+        return details.enabled && details.metadata && details.metadata.payload !== undefined;
+    })
+        .map((flag) => {
+        const payload = safeFlags[flag].metadata?.payload;
+        return [flag, payload ? parsePayload(payload) : undefined];
+    }));
+};
+const getFeatureFlagValue = (detail) => {
+    return detail === undefined ? undefined : detail.variant ?? detail.enabled;
+};
+const parsePayload = (response) => {
+    if (typeof response !== 'string') {
+        return response;
+    }
+    try {
+        return JSON.parse(response);
+    }
+    catch {
+        return response;
+    }
+};
+/**
+ * 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
+ */
+const createDecideResponseFromFlagsAndPayloads = (featureFlags, featureFlagPayloads) => {
+    // If a feature flag payload key is not in the feature flags, we treat it as true feature flag.
+    const allKeys = [...new Set([...Object.keys(featureFlags ?? {}), ...Object.keys(featureFlagPayloads ?? {})])];
+    const enabledFlags = allKeys
+        .filter((flag) => !!featureFlags[flag] || !!featureFlagPayloads[flag])
+        .reduce((res, key) => ((res[key] = featureFlags[key] ?? true), res), {});
+    const flagDetails = {
+        featureFlags: enabledFlags,
+        featureFlagPayloads: featureFlagPayloads ?? {},
+    };
+    return normalizeDecideResponse(flagDetails);
+};
+const updateFlagValue = (flag, value) => {
+    return {
+        ...flag,
+        enabled: getEnabledFromValue(value),
+        variant: getVariantFromValue(value),
+    };
+};
+function getEnabledFromValue(value) {
+    return typeof value === 'string' ? true : value;
+}
+function getVariantFromValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+
+// Rollout constants
+const NEW_FLAGS_ROLLOUT_PERCENTAGE = 1;
+// The fnv1a hashes of the tokens that are explicitly excluded from the rollout
+// see https://github.com/PostHog/posthog-js-lite/blob/main/posthog-core/src/utils.ts#L84
+// are hashed API tokens from our top 10 for each category supported by this SDK.
+const NEW_FLAGS_EXCLUDED_HASHES = new Set([
+    // Node
+    '61be3dd8',
+    '96f6df5f',
+    '8cfdba9b',
+    'bf027177',
+    'e59430a8',
+    '7fa5500b',
+    '569798e9',
+    '04809ff7',
+    '0ebc61a5',
+    '32de7f98',
+    '3beeb69a',
+    '12d34ad9',
+    '733853ec',
+    '0645bb64',
+    '5dcbee21',
+    'b1f95fa3',
+    '2189e408',
+    '82b460c2',
+    '3a8cc979',
+    '29ef8843',
+    '2cdbf767',
+    '38084b54',
+    // React Native
+    '50f9f8de',
+    '41d0df91',
+    '5c236689',
+    'c11aedd3',
+    'ada46672',
+    'f4331ee1',
+    '42fed62a',
+    'c957462c',
+    'd62f705a',
+    // Web (lots of teams per org, hence lots of API tokens)
+    'e0162666',
+    '01b3e5cf',
+    '441cef7f',
+    'bb9cafee',
+    '8f348eb0',
+    'b2553f3a',
+    '97469d7d',
+    '39f21a76',
+    '03706dcc',
+    '27d50569',
+    '307584a7',
+    '6433e92e',
+    '150c7fbb',
+    '49f57f22',
+    '3772f65b',
+    '01eb8256',
+    '3c9e9234',
+    'f853c7f7',
+    'c0ac4b67',
+    'cd609d40',
+    '10ca9b1a',
+    '8a87f11b',
+    '8e8e5216',
+    '1f6b63b3',
+    'db7943dd',
+    '79b7164c',
+    '07f78e33',
+    '2d21b6fd',
+    '952db5ee',
+    'a7d3b43f',
+    '1924dd9c',
+    '84e1b8f6',
+    'dff631b6',
+    'c5aa8a79',
+    'fa133a95',
+    '498a4508',
+    '24748755',
+    '98f3d658',
+    '21bbda67',
+    '7dbfed69',
+    'be3ec24c',
+    'fc80b8e2',
+    '75cc0998',
+]);
 function assert(truthyValue, message) {
-    if (!truthyValue) {
+    if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
         throw new Error(message);
     }
 }
+function isEmpty(truthyValue) {
+    if (truthyValue.trim().length === 0) {
+        return true;
+    }
+    return false;
+}
 function removeTrailingSlash(url) {
     return url?.replace(/\/+$/, '');
 }
@@ -71,6 +344,34 @@ const isError = (x) => {
 };
 function getFetch() {
     return typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
+}
+// copied from: https://github.com/PostHog/posthog-js/blob/main/react/src/utils/type-utils.ts#L4
+const isFunction = function (f) {
+    return typeof f === 'function';
+};
+// FNV-1a hash function
+// https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
+// I know, I know, I'm rolling my own hash function, but I didn't want to take on
+// a crypto dependency and this is just temporary anyway
+function fnv1a(str) {
+    let hash = 0x811c9dc5; // FNV offset basis
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    // Convert to hex string, padding to 8 chars
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function isTokenInRollout(token, percentage = 0, excludedHashes) {
+    const tokenHash = fnv1a(token);
+    // Check excluded hashes (we're explicitly including these tokens from the rollout)
+    if (excludedHashes?.has(tokenHash)) {
+        return false;
+    }
+    // Convert hash to int and divide by max value to get number between 0-1
+    const hashInt = parseInt(tokenHash, 16);
+    const hashFloat = hashInt / 0xffffffff;
+    return hashFloat < percentage;
 }
 
 // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
@@ -954,13 +1255,14 @@ class PostHogFetchNetworkError extends Error {
 function isPostHogFetchError(err) {
     return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
 }
+var QuotaLimitedFeature;
+(function (QuotaLimitedFeature) {
+    QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
+    QuotaLimitedFeature["Recordings"] = "recordings";
+})(QuotaLimitedFeature || (QuotaLimitedFeature = {}));
 class PostHogCoreStateless {
     constructor(apiKey, options) {
         this.flushPromise = null;
-        this.disableGeoip = true;
-        this.historicalMigration = false;
-        this.disabled = false;
-        this.defaultOptIn = true;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -973,8 +1275,10 @@ class PostHogCoreStateless {
         this.maxQueueSize = Math.max(this.flushAt, options?.maxQueueSize ?? 1000);
         this.flushInterval = options?.flushInterval ?? 10000;
         this.captureMode = options?.captureMode || 'json';
+        this.preloadFeatureFlags = options?.preloadFeatureFlags ?? true;
         // If enable is explicitly set to false we override the optout
         this.defaultOptIn = options?.defaultOptIn ?? true;
+        this.disableSurveys = options?.disableSurveys ?? false;
         this._retryOptions = {
             retryCount: options?.fetchRetryCount ?? 3,
             retryDelay: options?.fetchRetryDelay ?? 3000,
@@ -982,6 +1286,7 @@ class PostHogCoreStateless {
         };
         this.requestTimeout = options?.requestTimeout ?? 10000; // 10 seconds
         this.featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 3000; // 3 seconds
+        this.remoteConfigRequestTimeoutMs = options?.remoteConfigRequestTimeoutMs ?? 3000; // 3 seconds
         this.disableGeoip = options?.disableGeoip ?? true;
         this.disabled = options?.disabled ?? false;
         this.historicalMigration = options?.historicalMigration ?? false;
@@ -1118,12 +1423,39 @@ class PostHogCoreStateless {
             this.enqueue('capture', payload, options);
         });
     }
+    async getRemoteConfig() {
+        await this._initPromise;
+        let host = this.host;
+        if (host === 'https://us.i.posthog.com') {
+            host = 'https://us-assets.i.posthog.com';
+        }
+        else if (host === 'https://eu.i.posthog.com') {
+            host = 'https://eu-assets.i.posthog.com';
+        }
+        const url = `${host}/array/${this.apiKey}/config`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+        };
+        // Don't retry remote config API calls
+        return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.remoteConfigRequestTimeoutMs)
+            .then((response) => response.json())
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Remote config could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+    }
     /***
      *** FEATURE FLAGS
      ***/
     async getDecide(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         await this._initPromise;
-        const url = `${this.host}/decide/?v=3`;
+        // Check if the API token is in the new flags rollout
+        // This is a temporary measure to ensure that we can still use the old flags API
+        // while we migrate to the new flags API
+        const useFlags = isTokenInRollout(this.apiKey, NEW_FLAGS_ROLLOUT_PERCENTAGE, NEW_FLAGS_EXCLUDED_HASHES);
+        const url = useFlags ? `${this.host}/flags/?v=2` : `${this.host}/decide/?v=4`;
         const fetchOptions = {
             method: 'POST',
             headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
@@ -1139,6 +1471,7 @@ class PostHogCoreStateless {
         // Don't retry /decide API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
+            .then((response) => normalizeDecideResponse(response))
             .catch((error) => {
             this._events.emit('error', error);
             return undefined;
@@ -1146,23 +1479,41 @@ class PostHogCoreStateless {
     }
     async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
         await this._initPromise;
-        const featureFlags = await this.getFeatureFlagsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
-        if (!featureFlags) {
+        const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
+        if (flagDetailResponse === undefined) {
             // If we haven't loaded flags yet, or errored out, we respond with undefined
-            return undefined;
+            return {
+                response: undefined,
+                requestId: undefined,
+            };
         }
-        let response = featureFlags[key];
-        // `/decide` v3 returns all flags
+        let response = getFeatureFlagValue(flagDetailResponse.response);
         if (response === undefined) {
             // For cases where the flag is unknown, return false
             response = false;
         }
         // If we have flags we either return the value (true or string) or false
-        return response;
+        return {
+            response,
+            requestId: flagDetailResponse.requestId,
+        };
+    }
+    async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+        await this._initPromise;
+        const decideResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
+        if (decideResponse === undefined) {
+            return undefined;
+        }
+        const featureFlags = decideResponse.flags;
+        const flagDetail = featureFlags[key];
+        return {
+            response: flagDetail,
+            requestId: decideResponse.requestId,
+        };
     }
     async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
         await this._initPromise;
-        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip);
+        const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [key]);
         if (!payloads) {
             return undefined;
         }
@@ -1173,40 +1524,96 @@ class PostHogCoreStateless {
         }
         return response;
     }
-    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
-        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).payloads;
+        const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
         return payloads;
     }
-    _parsePayload(response) {
-        try {
-            return JSON.parse(response);
-        }
-        catch {
-            return response;
-        }
+    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+        await this._initPromise;
+        return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
     }
-    async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
-        return (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip)).flags;
+        const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+        if (!featureFlagDetails) {
+            return {
+                flags: undefined,
+                payloads: undefined,
+                requestId: undefined,
+            };
+        }
+        return {
+            flags: featureFlagDetails.featureFlags,
+            payloads: featureFlagDetails.featureFlagPayloads,
+            requestId: featureFlagDetails.requestId,
+        };
     }
-    async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
+    async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
         await this._initPromise;
         const extraPayload = {};
         if (disableGeoip ?? this.disableGeoip) {
             extraPayload['geoip_disable'] = true;
         }
+        if (flagKeysToEvaluate) {
+            extraPayload['flag_keys_to_evaluate'] = flagKeysToEvaluate;
+        }
         const decideResponse = await this.getDecide(distinctId, groups, personProperties, groupProperties, extraPayload);
-        const flags = decideResponse?.featureFlags;
-        const payloads = decideResponse?.featureFlagPayloads;
-        let parsedPayloads = payloads;
-        if (payloads) {
-            parsedPayloads = Object.fromEntries(Object.entries(payloads).map(([k, v]) => [k, this._parsePayload(v)]));
+        if (decideResponse === undefined) {
+            // We probably errored out, so return undefined
+            return undefined;
         }
-        return {
-            flags,
-            payloads: parsedPayloads,
+        // if there's an error on the decideResponse, log a console error, but don't throw an error
+        if (decideResponse.errorsWhileComputingFlags) {
+            console.error('[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices');
+        }
+        // Add check for quota limitation on feature flags
+        if (decideResponse.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
+            console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
+            return {
+                flags: {},
+                featureFlags: {},
+                featureFlagPayloads: {},
+                requestId: decideResponse?.requestId,
+            };
+        }
+        return decideResponse;
+    }
+    /***
+     *** SURVEYS
+     ***/
+    async getSurveysStateless() {
+        await this._initPromise;
+        if (this.disableSurveys === true) {
+            this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+            return [];
+        }
+        const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
+        const fetchOptions = {
+            method: 'GET',
+            headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
         };
+        const response = await this.fetchWithRetry(url, fetchOptions)
+            .then((response) => {
+            if (response.status !== 200 || !response.json) {
+                const msg = `Surveys API could not be loaded: ${response.status}`;
+                const error = new Error(msg);
+                this.logMsgIfDebug(() => console.error(error));
+                this._events.emit('error', new Error(msg));
+                return undefined;
+            }
+            return response.json();
+        })
+            .catch((error) => {
+            this.logMsgIfDebug(() => console.error('Surveys API could not be loaded', error));
+            this._events.emit('error', error);
+            return undefined;
+        });
+        const newSurveys = response?.surveys;
+        if (newSurveys) {
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from API: ', JSON.stringify(newSurveys)));
+        }
+        return newSurveys ?? [];
     }
     /***
      *** QUEUEING AND FLUSHING
@@ -1445,23 +1852,21 @@ class PostHogCore extends PostHogCoreStateless {
                 }
             }
         }
-        const bootstrapfeatureFlags = bootstrap.featureFlags;
-        if (bootstrapfeatureFlags && Object.keys(bootstrapfeatureFlags).length) {
-            const bootstrapFlags = Object.keys(bootstrapfeatureFlags)
-                .filter((flag) => !!bootstrapfeatureFlags[flag])
-                .reduce((res, key) => ((res[key] = bootstrapfeatureFlags[key] || false), res), {});
-            if (Object.keys(bootstrapFlags).length) {
-                this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlags, bootstrapFlags);
-                const currentFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags) || {};
-                const newFeatureFlags = { ...bootstrapFlags, ...currentFlags };
-                this.setKnownFeatureFlags(newFeatureFlags);
-            }
-            const bootstrapFlagPayloads = bootstrap.featureFlagPayloads;
-            if (bootstrapFlagPayloads && Object.keys(bootstrapFlagPayloads).length) {
-                this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagPayloads, bootstrapFlagPayloads);
-                const currentFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads) || {};
-                const newFeatureFlagPayloads = { ...bootstrapFlagPayloads, ...currentFlagPayloads };
-                this.setKnownFeatureFlagPayloads(newFeatureFlagPayloads);
+        const bootstrapFeatureFlags = bootstrap.featureFlags;
+        const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
+        if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
+            const normalizedBootstrapFeatureFlagDetails = createDecideResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
+                this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
+                const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || { flags: {}, requestId: undefined };
+                const newFeatureFlagDetails = {
+                    flags: {
+                        ...normalizedBootstrapFeatureFlagDetails.flags,
+                        ...currentFeatureFlagDetails.flags,
+                    },
+                    requestId: normalizedBootstrapFeatureFlagDetails.requestId,
+                };
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
             }
         }
     }
@@ -1699,7 +2104,7 @@ class PostHogCore extends PostHogCoreStateless {
     }
     resetPersonPropertiesForFlags() {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {});
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, null);
         });
     }
     /** @deprecated - Renamed to setPersonPropertiesForFlags */
@@ -1728,7 +2133,7 @@ class PostHogCore extends PostHogCoreStateless {
     }
     resetGroupPropertiesForFlags() {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {});
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, null);
         });
     }
     /** @deprecated - Renamed to setGroupPropertiesForFlags */
@@ -1737,6 +2142,13 @@ class PostHogCore extends PostHogCoreStateless {
             this.setGroupPropertiesForFlags(properties);
         });
     }
+    async remoteConfigAsync() {
+        await this._initPromise;
+        if (this._remoteConfigResponsePromise) {
+            return this._remoteConfigResponsePromise;
+        }
+        return this._remoteConfigAsync();
+    }
     /***
      *** FEATURE FLAGS
      ***/
@@ -1747,9 +2159,68 @@ class PostHogCore extends PostHogCoreStateless {
         }
         return this._decideAsync(sendAnonDistinctId);
     }
+    cacheSessionReplay(response) {
+        const sessionReplay = response?.sessionRecording;
+        if (sessionReplay) {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
+        }
+        else {
+            this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
+        }
+    }
+    async _remoteConfigAsync() {
+        this._remoteConfigResponsePromise = this._initPromise
+            .then(() => {
+            let remoteConfig = this.getPersistedProperty(PostHogPersistedProperty.RemoteConfig);
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached remote config: ', JSON.stringify(remoteConfig)));
+            return super.getRemoteConfig().then((response) => {
+                if (response) {
+                    const remoteConfigWithoutSurveys = { ...response };
+                    delete remoteConfigWithoutSurveys.surveys;
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Fetched remote config: ', JSON.stringify(remoteConfigWithoutSurveys)));
+                    const surveys = response.surveys;
+                    let hasSurveys = true;
+                    if (!Array.isArray(surveys)) {
+                        // If surveys is not an array, it means there are no surveys (its a boolean instead)
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'There are no surveys.'));
+                        hasSurveys = false;
+                    }
+                    else {
+                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Surveys fetched from remote config: ', JSON.stringify(surveys)));
+                    }
+                    if (this.disableSurveys === false && hasSurveys) {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveys);
+                    }
+                    else {
+                        this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                    }
+                    // we cache the surveys in its own storage key
+                    this.setPersistedProperty(PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
+                    this.cacheSessionReplay(response);
+                    // we only dont load flags if the remote config has no feature flags
+                    if (response.hasFeatureFlags === false) {
+                        // resetting flags to empty object
+                        this.setKnownFeatureFlagDetails({ flags: {} });
+                        this.logMsgIfDebug(() => console.warn('Remote config has no feature flags, will not load feature flags.'));
+                    }
+                    else if (this.preloadFeatureFlags !== false) {
+                        this.reloadFeatureFlags();
+                    }
+                    remoteConfig = response;
+                }
+                return remoteConfig;
+            });
+        })
+            .finally(() => {
+            this._remoteConfigResponsePromise = undefined;
+        });
+        return this._remoteConfigResponsePromise;
+    }
     async _decideAsync(sendAnonDistinctId = true) {
         this._decideResponsePromise = this._initPromise
-            .then(() => {
+            .then(async () => {
             const distinctId = this.getDistinctId();
             const groups = this.props.$groups || {};
             const personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
@@ -1758,76 +2229,126 @@ class PostHogCore extends PostHogCoreStateless {
             const extraProperties = {
                 $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : undefined,
             };
-            return super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties).then((res) => {
-                if (res?.featureFlags) {
-                    // clear flag call reported if we have new flags since they might have changed
-                    if (this.sendFeatureFlagEvent) {
-                        this.flagCallReported = {};
-                    }
-                    let newFeatureFlags = res.featureFlags;
-                    let newFeatureFlagPayloads = res.featureFlagPayloads;
-                    if (res.errorsWhileComputingFlags) {
-                        // if not all flags were computed, we upsert flags instead of replacing them
-                        const currentFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
-                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlags)));
-                        const currentFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
-                        newFeatureFlags = { ...currentFlags, ...res.featureFlags };
-                        newFeatureFlagPayloads = { ...currentFlagPayloads, ...res.featureFlagPayloads };
-                    }
-                    this.setKnownFeatureFlags(newFeatureFlags);
-                    this.setKnownFeatureFlagPayloads(Object.fromEntries(Object.entries(newFeatureFlagPayloads || {}).map(([k, v]) => [k, this._parsePayload(v)])));
-                    // Mark that we hit the /decide endpoint so we can capture this in the $feature_flag_called event
-                    this.setPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit, true);
-                    const sessionReplay = res?.sessionRecording;
-                    if (sessionReplay) {
-                        this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
-                        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
-                    }
-                    else {
-                        this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
-                        this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
-                    }
-                }
+            const res = await super.getDecide(distinctId, groups, personProperties, groupProperties, extraProperties);
+            // Add check for quota limitation on feature flags
+            if (res?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
+                // Unset all feature flags by setting to null
+                this.setKnownFeatureFlagDetails(null);
+                console.warn('[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts');
                 return res;
-            });
+            }
+            if (res?.featureFlags) {
+                // clear flag call reported if we have new flags since they might have changed
+                if (this.sendFeatureFlagEvent) {
+                    this.flagCallReported = {};
+                }
+                let newFeatureFlagDetails = res;
+                if (res.errorsWhileComputingFlags) {
+                    // if not all flags were computed, we upsert flags instead of replacing them
+                    const currentFlagDetails = this.getKnownFeatureFlagDetails();
+                    this.logMsgIfDebug(() => console.log('PostHog Debug', 'Cached feature flags: ', JSON.stringify(currentFlagDetails)));
+                    newFeatureFlagDetails = {
+                        ...res,
+                        flags: { ...currentFlagDetails?.flags, ...res.flags },
+                    };
+                }
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+                // Mark that we hit the /decide endpoint so we can capture this in the $feature_flag_called event
+                this.setPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit, true);
+                this.cacheSessionReplay(res);
+            }
+            return res;
         })
             .finally(() => {
             this._decideResponsePromise = undefined;
         });
         return this._decideResponsePromise;
     }
-    setKnownFeatureFlags(featureFlags) {
+    // We only store the flags and request id in the feature flag details storage key
+    setKnownFeatureFlagDetails(decideResponse) {
         this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlags, featureFlags);
-            this._events.emit('featureflags', featureFlags);
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, decideResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags(decideResponse?.flags ?? {}));
         });
     }
-    setKnownFeatureFlagPayloads(featureFlagPayloads) {
-        this.wrap(() => {
-            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads, featureFlagPayloads);
-        });
+    getKnownFeatureFlagDetails() {
+        const storedDetails = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails);
+        if (!storedDetails) {
+            // Rebuild from the stored feature flags and feature flag payloads
+            const featureFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+            const featureFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+            if (featureFlags === undefined && featureFlagPayloads === undefined) {
+                return undefined;
+            }
+            return createDecideResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+        }
+        return normalizeDecideResponse(storedDetails);
+    }
+    getKnownFeatureFlags() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(featureFlagDetails.flags);
+    }
+    getKnownFeatureFlagPayloads() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(featureFlagDetails.flags);
+    }
+    getBootstrappedFeatureFlagDetails() {
+        const details = this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails);
+        if (!details) {
+            return undefined;
+        }
+        return details;
+    }
+    setBootstrappedFeatureFlagDetails(details) {
+        this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails, details);
+    }
+    getBootstrappedFeatureFlags() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getFlagValuesFromFlags(details.flags);
+    }
+    getBootstrappedFeatureFlagPayloads() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) {
+            return undefined;
+        }
+        return getPayloadsFromFlags(details.flags);
     }
     getFeatureFlag(key) {
-        const featureFlags = this.getFeatureFlags();
-        if (!featureFlags) {
+        const details = this.getFeatureFlagDetails();
+        if (!details) {
             // If we haven't loaded flags yet, or errored out, we respond with undefined
             return undefined;
         }
-        let response = featureFlags[key];
-        // `/decide` v3 returns all flags
+        const featureFlag = details.flags[key];
+        let response = getFeatureFlagValue(featureFlag);
         if (response === undefined) {
             // For cases where the flag is unknown, return false
             response = false;
         }
         if (this.sendFeatureFlagEvent && !this.flagCallReported[key]) {
+            const bootstrappedResponse = this.getBootstrappedFeatureFlags()?.[key];
+            const bootstrappedPayload = this.getBootstrappedFeatureFlagPayloads()?.[key];
             this.flagCallReported[key] = true;
             this.capture('$feature_flag_called', {
                 $feature_flag: key,
                 $feature_flag_response: response,
-                $feature_flag_bootstrapped_response: this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlags)?.[key],
-                $feature_flag_bootstrapped_payload: this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagPayloads)?.[key],
+                $feature_flag_id: featureFlag?.metadata?.id,
+                $feature_flag_version: featureFlag?.metadata?.version,
+                $feature_flag_reason: featureFlag?.reason?.description ?? featureFlag?.reason?.code,
+                $feature_flag_bootstrapped_response: bootstrappedResponse,
+                $feature_flag_bootstrapped_payload: bootstrappedPayload,
                 // If we haven't yet received a response from the /decide endpoint, we must have used the bootstrapped value
                 $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.DecideEndpointWasHit),
+                $feature_flag_request_id: details.requestId,
             });
         }
         // If we have flags we either return the value (true or string) or false
@@ -1846,27 +2367,36 @@ class PostHogCore extends PostHogCoreStateless {
         return response;
     }
     getFeatureFlagPayloads() {
-        const payloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
-        return payloads;
+        return this.getFeatureFlagDetails()?.featureFlagPayloads;
     }
     getFeatureFlags() {
         // NOTE: We don't check for _initPromise here as the function is designed to be
         // callable before the state being loaded anyways
-        let flags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+        return this.getFeatureFlagDetails()?.featureFlags;
+    }
+    getFeatureFlagDetails() {
+        // NOTE: We don't check for _initPromise here as the function is designed to be
+        // callable before the state being loaded anyways
+        let details = this.getKnownFeatureFlagDetails();
         const overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
         if (!overriddenFlags) {
-            return flags;
+            return details;
         }
-        flags = flags || {};
+        details = details ?? { featureFlags: {}, featureFlagPayloads: {}, flags: {} };
+        const flags = details.flags ?? {};
         for (const key in overriddenFlags) {
             if (!overriddenFlags[key]) {
                 delete flags[key];
             }
             else {
-                flags[key] = overriddenFlags[key];
+                flags[key] = updateFlagValue(flags[key], overriddenFlags[key]);
             }
         }
-        return flags;
+        const result = {
+            ...details,
+            flags,
+        };
+        return normalizeDecideResponse(result);
     }
     getFeatureFlagsAndPayloads() {
         const flags = this.getFeatureFlags();
@@ -1896,6 +2426,9 @@ class PostHogCore extends PostHogCoreStateless {
             }
         });
     }
+    async reloadRemoteConfigAsync() {
+        return await this.remoteConfigAsync();
+    }
     async reloadFeatureFlagsAsync(sendAnonDistinctId = true) {
         return (await this.decideAsync(sendAnonDistinctId))?.featureFlags;
     }
@@ -1970,7 +2503,7 @@ class PostHogCore extends PostHogCoreStateless {
     }
 }
 
-var version = "3.4.1";
+var version = "3.5.0";
 
 function getContext(window) {
   let context = {};
@@ -2275,9 +2808,45 @@ const getStorage = (type, window) => {
   }
 };
 
+// import { patch } from 'rrweb/typings/utils'
+function patch(source, name, replacement) {
+    try {
+        if (!(name in source)) {
+            return () => {
+                //
+            };
+        }
+        const original = source[name];
+        const wrapped = replacement(original);
+        // Make sure it's a function first, as we need to attach an empty prototype for `defineProperties` to work
+        // otherwise it'll throw "TypeError: Object.defineProperties called on non-object"
+        if (isFunction(wrapped)) {
+            wrapped.prototype = wrapped.prototype || {};
+            Object.defineProperties(wrapped, {
+                __posthog_wrapped__: {
+                    enumerable: false,
+                    value: true,
+                },
+            });
+        }
+        source[name] = wrapped;
+        return () => {
+            source[name] = original;
+        };
+    }
+    catch {
+        return () => {
+            //
+        };
+        // This can throw if multiple fill happens on a global object like XMLHttpRequest
+        // Fixes https://github.com/getsentry/sentry-javascript/issues/2043
+    }
+}
+
 class PostHog extends PostHogCore {
   constructor(apiKey, options) {
     super(apiKey, options);
+    this._lastPathname = '';
     // posthog-js stores options in one object on
     this._storageKey = options?.persistence_name ? `ph_${options.persistence_name}` : `ph_${apiKey}_posthog`;
     this._storage = getStorage(options?.persistence || 'localStorage', this.getWindow());
@@ -2285,6 +2854,10 @@ class PostHog extends PostHogCore {
     if (options?.preloadFeatureFlags !== false) {
       this.reloadFeatureFlags();
     }
+    if (options?.captureHistoryEvents && typeof window !== 'undefined') {
+      this._lastPathname = window?.location?.pathname || '';
+      this.setupHistoryEventTracking();
+    }
   }
   getWindow() {
     return typeof window !== 'undefined' ? window : undefined;
@@ -2329,6 +2902,47 @@ class PostHog extends PostHogCore {
       ...getContext(this.getWindow())
     };
   }
+  setupHistoryEventTracking() {
+    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(state, title, url) {
+        ;
+        originalPushState.call(this, state, title, url);
+        self.captureNavigationEvent('pushState');
+      };
+    });
+    patch(window.history, 'replaceState', originalReplaceState => {
+      return function patchedReplaceState(state, title, url) {
+        ;
+        originalReplaceState.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');
+    });
+  }
+  captureNavigationEvent(navigationType) {
+    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;
+    }
+  }
 }
 
 exports.PostHog = PostHog;