posthog-js-lite 3.5.0 → 3.6.0

package/lib/{index.cjs.js → index.cjs}

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var version = "3.6.0";
+
 var PostHogPersistedProperty;
 (function (PostHogPersistedProperty) {
     PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
@@ -17,6 +19,7 @@ var PostHogPersistedProperty;
     PostHogPersistedProperty["Queue"] = "queue";
     PostHogPersistedProperty["OptedOut"] = "opted_out";
     PostHogPersistedProperty["SessionId"] = "session_id";
+    PostHogPersistedProperty["SessionStartTimestamp"] = "session_start_timestamp";
     PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
     PostHogPersistedProperty["PersonProperties"] = "person_properties";
     PostHogPersistedProperty["GroupProperties"] = "group_properties";
@@ -291,6 +294,7 @@ const NEW_FLAGS_EXCLUDED_HASHES = new Set([
     'fc80b8e2',
     '75cc0998',
 ]);
+const STRING_FORMAT = 'utf8';
 function assert(truthyValue, message) {
     if (!truthyValue || typeof truthyValue !== 'string' || isEmpty(truthyValue)) {
         throw new Error(message);
@@ -343,12 +347,8 @@ const isError = (x) => {
     return x instanceof Error;
 };
 function getFetch() {
-    return typeof fetch !== 'undefined' ? fetch : typeof global.fetch !== 'undefined' ? global.fetch : undefined;
+    return typeof fetch !== 'undefined' ? fetch : typeof globalThis.fetch !== 'undefined' ? globalThis.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
@@ -372,6 +372,9 @@ function isTokenInRollout(token, percentage = 0, excludedHashes) {
     const hashInt = parseInt(tokenHash, 16);
     const hashFloat = hashInt / 0xffffffff;
     return hashFloat < percentage;
+}
+function allSettled(promises) {
+    return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason }))));
 }
 
 // Copyright (c) 2013 Pieroxy <pieroxy@pieroxy.net>
@@ -1236,11 +1239,21 @@ const uuidv7 = () => uuidv7obj().toString();
 const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
 
 class PostHogFetchHttpError extends Error {
-    constructor(response) {
-        super('HTTP error while fetching PostHog: ' + response.status);
+    constructor(response, reqByteLength) {
+        super('HTTP error while fetching PostHog: status=' + response.status + ', reqByteLength=' + reqByteLength);
         this.response = response;
+        this.reqByteLength = reqByteLength;
         this.name = 'PostHogFetchHttpError';
     }
+    get status() {
+        return this.response.status;
+    }
+    get text() {
+        return this.response.text();
+    }
+    get json() {
+        return this.response.json();
+    }
 }
 class PostHogFetchNetworkError extends Error {
     constructor(error) {
@@ -1252,9 +1265,27 @@ class PostHogFetchNetworkError extends Error {
         this.name = 'PostHogFetchNetworkError';
     }
 }
+const maybeAdd = (key, value) => value !== undefined ? { [key]: value } : {};
+async function logFlushError(err) {
+    if (err instanceof PostHogFetchHttpError) {
+        let text = '';
+        try {
+            text = await err.text;
+        }
+        catch { }
+        console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
+    }
+    else {
+        console.error('Error while flushing PostHog', err);
+    }
+    return Promise.resolve();
+}
 function isPostHogFetchError(err) {
     return typeof err === 'object' && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
 }
+function isPostHogFetchContentTooLargeError(err) {
+    return typeof err === 'object' && err instanceof PostHogFetchHttpError && err.status === 413;
+}
 var QuotaLimitedFeature;
 (function (QuotaLimitedFeature) {
     QuotaLimitedFeature["FeatureFlags"] = "feature_flags";
@@ -1263,6 +1294,7 @@ var QuotaLimitedFeature;
 class PostHogCoreStateless {
     constructor(apiKey, options) {
         this.flushPromise = null;
+        this.shutdownPromise = null;
         this.pendingPromises = {};
         // internal
         this._events = new SimpleEventEmitter();
@@ -1385,12 +1417,26 @@ class PostHogCoreStateless {
             this.enqueue('identify', payload, options);
         });
     }
+    async identifyStatelessImmediate(distinctId, properties, options) {
+        const payload = {
+            ...this.buildPayload({
+                distinct_id: distinctId,
+                event: '$identify',
+                properties,
+            }),
+        };
+        await this.sendImmediate('identify', payload, options);
+    }
     captureStateless(distinctId, event, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
             this.enqueue('capture', payload, options);
         });
     }
+    async captureStatelessImmediate(distinctId, event, properties, options) {
+        const payload = this.buildPayload({ distinct_id: distinctId, event, properties });
+        await this.sendImmediate('capture', payload, options);
+    }
     aliasStateless(alias, distinctId, properties, options) {
         this.wrap(() => {
             const payload = this.buildPayload({
@@ -1405,6 +1451,18 @@ class PostHogCoreStateless {
             this.enqueue('alias', payload, options);
         });
     }
+    async aliasStatelessImmediate(alias, distinctId, properties, options) {
+        const payload = this.buildPayload({
+            event: '$create_alias',
+            distinct_id: distinctId,
+            properties: {
+                ...(properties || {}),
+                distinct_id: distinctId,
+                alias,
+            },
+        });
+        await this.sendImmediate('alias', payload, options);
+    }
     /***
      *** GROUPS
      ***/
@@ -1468,6 +1526,7 @@ class PostHogCoreStateless {
                 ...extraPayload,
             }),
         };
+        this.logMsgIfDebug(() => console.log('PostHog Debug', 'Decide URL', url));
         // Don't retry /decide API calls
         return this.fetchWithRetry(url, fetchOptions, { retryCount: 0 }, this.featureFlagsRequestTimeoutMs)
             .then((response) => response.json())
@@ -1585,7 +1644,7 @@ class PostHogCoreStateless {
     async getSurveysStateless() {
         await this._initPromise;
         if (this.disableSurveys === true) {
-            this.logMsgIfDebug(() => console.log('Loading surveys is disabled.'));
+            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Loading surveys is disabled.'));
             return [];
         }
         const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
@@ -1615,6 +1674,30 @@ class PostHogCoreStateless {
         }
         return newSurveys ?? [];
     }
+    get props() {
+        if (!this._props) {
+            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
+        }
+        return this._props || {};
+    }
+    set props(val) {
+        this._props = val;
+    }
+    async register(properties) {
+        this.wrap(() => {
+            this.props = {
+                ...this.props,
+                ...properties,
+            };
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
+    async unregister(property) {
+        this.wrap(() => {
+            delete this.props[property];
+            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
+        });
+    }
     /***
      *** QUEUEING AND FLUSHING
      ***/
@@ -1624,25 +1707,7 @@ class PostHogCoreStateless {
                 this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
                 return;
             }
-            const message = {
-                ..._message,
-                type: type,
-                library: this.getLibraryId(),
-                library_version: this.getLibraryVersion(),
-                timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
-                uuid: options?.uuid ? options.uuid : uuidv7(),
-            };
-            const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
-            if (addGeoipDisableProperty) {
-                if (!message.properties) {
-                    message.properties = {};
-                }
-                message['properties']['$geoip_disable'] = true;
-            }
-            if (message.distinctId) {
-                message.distinct_id = message.distinctId;
-                delete message.distinctId;
-            }
+            const message = this.prepareMessage(type, _message, options);
             const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
             if (queue.length >= this.maxQueueSize) {
                 queue.shift();
@@ -1660,6 +1725,72 @@ class PostHogCoreStateless {
             }
         });
     }
+    async sendImmediate(type, _message, options) {
+        if (this.disabled) {
+            this.logMsgIfDebug(() => console.warn('[PostHog] The client is disabled'));
+            return;
+        }
+        if (!this._isInitialized) {
+            await this._initPromise;
+        }
+        if (this.optedOut) {
+            this._events.emit(type, `Library is disabled. Not sending event. To re-enable, call posthog.optIn()`);
+            return;
+        }
+        const data = {
+            api_key: this.apiKey,
+            batch: [this.prepareMessage(type, _message, options)],
+            sent_at: currentISOTime(),
+        };
+        if (this.historicalMigration) {
+            data.historical_migration = true;
+        }
+        const payload = JSON.stringify(data);
+        const url = this.captureMode === 'form'
+            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+            : `${this.host}/batch/`;
+        const fetchOptions = this.captureMode === 'form'
+            ? {
+                method: 'POST',
+                mode: 'no-cors',
+                credentials: 'omit',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+            }
+            : {
+                method: 'POST',
+                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                body: payload,
+            };
+        try {
+            await this.fetchWithRetry(url, fetchOptions);
+        }
+        catch (err) {
+            this._events.emit('error', err);
+        }
+    }
+    prepareMessage(type, _message, options) {
+        const message = {
+            ..._message,
+            type: type,
+            library: this.getLibraryId(),
+            library_version: this.getLibraryVersion(),
+            timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+            uuid: options?.uuid ? options.uuid : uuidv7(),
+        };
+        const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+        if (addGeoipDisableProperty) {
+            if (!message.properties) {
+                message.properties = {};
+            }
+            message['properties']['$geoip_disable'] = true;
+        }
+        if (message.distinctId) {
+            message.distinct_id = message.distinctId;
+            delete message.distinctId;
+        }
+        return message;
+    }
     clearFlushTimer() {
         if (this._flushTimer) {
             clearTimeout(this._flushTimer);
@@ -1671,16 +1802,49 @@ class PostHogCoreStateless {
      * Avoids unnecessary promise errors
      */
     flushBackground() {
-        void this.flush().catch(() => { });
+        void this.flush().catch(async (err) => {
+            await logFlushError(err);
+        });
     }
+    /**
+     * Flushes the queue
+     *
+     * This function will return a promise that will resolve when the flush is complete,
+     * or reject if there was an error (for example if the server or network is down).
+     *
+     * If there is already a flush in progress, this function will wait for that flush to complete.
+     *
+     * It's recommended to do error handling in the callback of the promise.
+     *
+     * @example
+     * posthog.flush().then(() => {
+     *   console.log('Flush complete')
+     * }).catch((err) => {
+     *   console.error('Flush failed', err)
+     * })
+     *
+     *
+     * @throws PostHogFetchHttpError
+     * @throws PostHogFetchNetworkError
+     * @throws Error
+     */
     async flush() {
-        if (!this.flushPromise) {
-            this.flushPromise = this._flush().finally(() => {
+        // Wait for the current flush operation to finish (regardless of success or failure), then try to flush again.
+        // Use allSettled instead of finally to be defensive around flush throwing errors immediately rather than rejecting.
+        // Use a custom allSettled implementation to avoid issues with patching Promise on RN
+        const nextFlushPromise = allSettled([this.flushPromise]).then(() => {
+            return this._flush();
+        });
+        this.flushPromise = nextFlushPromise;
+        void this.addPendingPromise(nextFlushPromise);
+        allSettled([nextFlushPromise]).then(() => {
+            // If there are no others waiting to flush, clear the promise.
+            // We don't strictly need to do this, but it could make debugging easier
+            if (this.flushPromise === nextFlushPromise) {
                 this.flushPromise = null;
-            });
-            this.addPendingPromise(this.flushPromise);
-        }
-        return this.flushPromise;
+            }
+        });
+        return nextFlushPromise;
     }
     getCustomHeaders() {
         // Don't set the user agent if we're not on a browser. The latest spec allows
@@ -1697,56 +1861,79 @@ class PostHogCoreStateless {
     async _flush() {
         this.clearFlushTimer();
         await this._initPromise;
-        const queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+        let queue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
         if (!queue.length) {
-            return [];
-        }
-        const items = queue.slice(0, this.maxBatchSize);
-        const messages = items.map((item) => item.message);
-        const persistQueueChange = () => {
-            const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
-            this.setPersistedProperty(PostHogPersistedProperty.Queue, refreshedQueue.slice(items.length));
-        };
-        const data = {
-            api_key: this.apiKey,
-            batch: messages,
-            sent_at: currentISOTime(),
-        };
-        if (this.historicalMigration) {
-            data.historical_migration = true;
+            return;
         }
-        const payload = JSON.stringify(data);
-        const url = this.captureMode === 'form'
-            ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
-            : `${this.host}/batch/`;
-        const fetchOptions = this.captureMode === 'form'
-            ? {
-                method: 'POST',
-                mode: 'no-cors',
-                credentials: 'omit',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
-                body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+        const sentMessages = [];
+        const originalQueueLength = queue.length;
+        while (queue.length > 0 && sentMessages.length < originalQueueLength) {
+            const batchItems = queue.slice(0, this.maxBatchSize);
+            const batchMessages = batchItems.map((item) => item.message);
+            const persistQueueChange = () => {
+                const refreshedQueue = this.getPersistedProperty(PostHogPersistedProperty.Queue) || [];
+                const newQueue = refreshedQueue.slice(batchItems.length);
+                this.setPersistedProperty(PostHogPersistedProperty.Queue, newQueue);
+                queue = newQueue;
+            };
+            const data = {
+                api_key: this.apiKey,
+                batch: batchMessages,
+                sent_at: currentISOTime(),
+            };
+            if (this.historicalMigration) {
+                data.historical_migration = true;
             }
-            : {
-                method: 'POST',
-                headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
-                body: payload,
+            const payload = JSON.stringify(data);
+            const url = this.captureMode === 'form'
+                ? `${this.host}/e/?ip=1&_=${currentTimestamp()}&v=${this.getLibraryVersion()}`
+                : `${this.host}/batch/`;
+            const fetchOptions = this.captureMode === 'form'
+                ? {
+                    method: 'POST',
+                    mode: 'no-cors',
+                    credentials: 'omit',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/x-www-form-urlencoded' },
+                    body: `data=${encodeURIComponent(LZString.compressToBase64(payload))}&compression=lz64`,
+                }
+                : {
+                    method: 'POST',
+                    headers: { ...this.getCustomHeaders(), 'Content-Type': 'application/json' },
+                    body: payload,
+                };
+            const retryOptions = {
+                retryCheck: (err) => {
+                    // don't automatically retry on 413 errors, we want to reduce the batch size first
+                    if (isPostHogFetchContentTooLargeError(err)) {
+                        return false;
+                    }
+                    // otherwise, retry on network errors
+                    return isPostHogFetchError(err);
+                },
             };
-        try {
-            await this.fetchWithRetry(url, fetchOptions);
-        }
-        catch (err) {
-            // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
-            // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
-            if (!(err instanceof PostHogFetchNetworkError)) {
-                persistQueueChange();
+            try {
+                await this.fetchWithRetry(url, fetchOptions, retryOptions);
             }
-            this._events.emit('error', err);
-            throw err;
+            catch (err) {
+                if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
+                    // if we get a 413 error, we want to reduce the batch size and try again
+                    this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
+                    this.logMsgIfDebug(() => console.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`));
+                    // do not persist the queue change, we want to retry the same batch
+                    continue;
+                }
+                // depending on the error type, eg a malformed JSON or broken queue, it'll always return an error
+                // and this will be an endless loop, in this case, if the error isn't a network issue, we always remove the items from the queue
+                if (!(err instanceof PostHogFetchNetworkError)) {
+                    persistQueueChange();
+                }
+                this._events.emit('error', err);
+                throw err;
+            }
+            persistQueueChange();
+            sentMessages.push(...batchMessages);
         }
-        persistQueueChange();
-        this._events.emit('flush', messages);
-        return messages;
+        this._events.emit('flush', sentMessages);
     }
     async fetchWithRetry(url, options, retryOptions, requestTimeout) {
         var _a;
@@ -1755,6 +1942,15 @@ class PostHogCoreStateless {
             setTimeout(() => ctrl.abort(), ms);
             return ctrl.signal;
         });
+        const body = options.body ? options.body : '';
+        let reqByteLength = -1;
+        try {
+            reqByteLength = Buffer.byteLength(body, STRING_FORMAT);
+        }
+        catch {
+            const encoded = new TextEncoder().encode(body);
+            reqByteLength = encoded.length;
+        }
         return await retriable(async () => {
             let res = null;
             try {
@@ -1772,12 +1968,12 @@ class PostHogCoreStateless {
             // https://developer.mozilla.org/en-US/docs/Web/API/Request/mode#no-cors
             const isNoCors = options.mode === 'no-cors';
             if (!isNoCors && (res.status < 200 || res.status >= 400)) {
-                throw new PostHogFetchHttpError(res);
+                throw new PostHogFetchHttpError(res, reqByteLength);
             }
             return res;
         }, { ...this._retryOptions, ...retryOptions });
     }
-    async shutdown(shutdownTimeoutMs = 30000) {
+    async _shutdown(shutdownTimeoutMs = 30000) {
         // A little tricky - we want to have a max shutdown time and enforce it, even if that means we have some
         // dangling promises. We'll keep track of the timeout and resolve/reject based on that.
         await this._initPromise;
@@ -1804,7 +2000,7 @@ class PostHogCoreStateless {
                 if (!isPostHogFetchError(e)) {
                     throw e;
                 }
-                this.logMsgIfDebug(() => console.error('Error while shutting down PostHog', e));
+                await logFlushError(e);
             }
         };
         return Promise.race([
@@ -1818,6 +2014,22 @@ class PostHogCoreStateless {
             doShutdown(),
         ]);
     }
+    /**
+     *  Call shutdown() once before the node process exits, so ensure that all events have been sent and all promises
+     *  have resolved. Do not use this function if you intend to keep using this PostHog instance after calling it.
+     * @param shutdownTimeoutMs
+     */
+    async shutdown(shutdownTimeoutMs = 30000) {
+        if (this.shutdownPromise) {
+            this.logMsgIfDebug(() => console.warn('shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup'));
+        }
+        else {
+            this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
+                this.shutdownPromise = null;
+            });
+        }
+        return this.shutdownPromise;
+    }
 }
 class PostHogCore extends PostHogCoreStateless {
     constructor(apiKey, options) {
@@ -1827,6 +2039,7 @@ class PostHogCore extends PostHogCoreStateless {
         const featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 10000; // 10 seconds
         super(apiKey, { ...options, disableGeoip: disableGeoipOption, featureFlagsRequestTimeoutMs });
         this.flagCallReported = {};
+        this._sessionMaxLengthSeconds = 24 * 60 * 60; // 24 hours
         this.sessionProps = {};
         this.sendFeatureFlagEvent = options?.sendFeatureFlagEvent ?? true;
         this._sessionExpirationTimeSeconds = options?.sessionExpirationTimeSeconds ?? 1800; // 30 minutes
@@ -1870,16 +2083,6 @@ class PostHogCore extends PostHogCoreStateless {
             }
         }
     }
-    // NOTE: Props are lazy loaded from localstorage hence the complex getter setter logic
-    get props() {
-        if (!this._props) {
-            this._props = this.getPersistedProperty(PostHogPersistedProperty.Props);
-        }
-        return this._props || {};
-    }
-    set props(val) {
-        this._props = val;
-    }
     clearProps() {
         this.props = undefined;
         this.sessionProps = {};
@@ -1910,7 +2113,7 @@ class PostHogCore extends PostHogCoreStateless {
             }
         }
         return {
-            $active_feature_flags: featureFlags ? Object.keys(featureFlags) : undefined,
+            ...maybeAdd('$active_feature_flags', featureFlags ? Object.keys(featureFlags) : undefined),
             ...featureVariantProperties,
             ...super.getCommonEventProperties(),
         };
@@ -1932,18 +2135,26 @@ class PostHogCore extends PostHogCoreStateless {
             return '';
         }
         let sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
-        const sessionTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
-        if (!sessionId || Date.now() - sessionTimestamp > this._sessionExpirationTimeSeconds * 1000) {
+        const sessionLastTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp) || 0;
+        const sessionStartTimestamp = this.getPersistedProperty(PostHogPersistedProperty.SessionStartTimestamp) || 0;
+        const now = Date.now();
+        const sessionLastDif = now - sessionLastTimestamp;
+        const sessionStartDif = now - sessionStartTimestamp;
+        if (!sessionId ||
+            sessionLastDif > this._sessionExpirationTimeSeconds * 1000 ||
+            sessionStartDif > this._sessionMaxLengthSeconds * 1000) {
             sessionId = uuidv7();
             this.setPersistedProperty(PostHogPersistedProperty.SessionId, sessionId);
+            this.setPersistedProperty(PostHogPersistedProperty.SessionStartTimestamp, now);
         }
-        this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, Date.now());
+        this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, now);
         return sessionId;
     }
     resetSessionId() {
         this.wrap(() => {
             this.setPersistedProperty(PostHogPersistedProperty.SessionId, null);
             this.setPersistedProperty(PostHogPersistedProperty.SessionLastTimestamp, null);
+            this.setPersistedProperty(PostHogPersistedProperty.SessionStartTimestamp, null);
         });
     }
     /**
@@ -1969,21 +2180,6 @@ class PostHogCore extends PostHogCoreStateless {
         }
         return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
     }
-    async unregister(property) {
-        this.wrap(() => {
-            delete this.props[property];
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
-    async register(properties) {
-        this.wrap(() => {
-            this.props = {
-                ...this.props,
-                ...properties,
-            };
-            this.setPersistedProperty(PostHogPersistedProperty.Props, this.props);
-        });
-    }
     registerForSession(properties) {
         this.sessionProps = {
             ...this.sessionProps,
@@ -2010,8 +2206,8 @@ class PostHogCore extends PostHogCoreStateless {
             const userProps = properties?.$set || properties;
             const allProperties = this.enrichProperties({
                 $anon_distinct_id: this.getAnonymousId(),
-                $set: userProps,
-                $set_once: userPropsOnce,
+                ...maybeAdd('$set', userProps),
+                ...maybeAdd('$set_once', userPropsOnce),
             });
             if (distinctId !== previousDistinctId) {
                 // We keep the AnonymousId to be used by decide calls and identify to link the previousId
@@ -2159,14 +2355,16 @@ class PostHogCore extends PostHogCoreStateless {
         }
         return this._decideAsync(sendAnonDistinctId);
     }
-    cacheSessionReplay(response) {
+    cacheSessionReplay(source, response) {
         const sessionReplay = response?.sessionRecording;
         if (sessionReplay) {
             this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
-            this.logMsgIfDebug(() => console.log('PostHog Debug', 'Session replay config: ', JSON.stringify(sessionReplay)));
+            this.logMsgIfDebug(() => console.log('PostHog Debug', `Session replay config from ${source}: `, JSON.stringify(sessionReplay)));
         }
-        else {
-            this.logMsgIfDebug(() => console.info('PostHog Debug', 'Session replay config disabled.'));
+        else if (typeof sessionReplay === 'boolean' && sessionReplay === false) {
+            // if session replay is disabled, we don't need to cache it
+            // we need to check for this because the response might be undefined (/flags does not return sessionRecording yet)
+            this.logMsgIfDebug(() => console.info('PostHog Debug', `Session replay config from ${source} disabled.`));
             this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, null);
         }
     }
@@ -2180,25 +2378,30 @@ class PostHogCore extends PostHogCoreStateless {
                     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);
+                    if (this.disableSurveys === false) {
+                        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 (hasSurveys) {
+                            this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveys);
+                        }
+                        else {
+                            this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                        }
                     }
                     else {
                         this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
                     }
                     // we cache the surveys in its own storage key
                     this.setPersistedProperty(PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
-                    this.cacheSessionReplay(response);
+                    this.cacheSessionReplay('remote config', response);
                     // we only dont load flags if the remote config has no feature flags
                     if (response.hasFeatureFlags === false) {
                         // resetting flags to empty object
@@ -2255,7 +2458,7 @@ class PostHogCore extends PostHogCoreStateless {
                 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);
+                this.cacheSessionReplay('decide/flags', res);
             }
             return res;
         })
@@ -2341,14 +2544,14 @@ class PostHogCore extends PostHogCoreStateless {
             this.capture('$feature_flag_called', {
                 $feature_flag: key,
                 $feature_flag_response: response,
-                $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,
+                ...maybeAdd('$feature_flag_id', featureFlag?.metadata?.id),
+                ...maybeAdd('$feature_flag_version', featureFlag?.metadata?.version),
+                ...maybeAdd('$feature_flag_reason', featureFlag?.reason?.description ?? featureFlag?.reason?.code),
+                ...maybeAdd('$feature_flag_bootstrapped_response', bootstrappedResponse),
+                ...maybeAdd('$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,
+                ...maybeAdd('$feature_flag_request_id', details.requestId),
             });
         }
         // If we have flags we either return the value (true or string) or false
@@ -2422,7 +2625,7 @@ class PostHogCore extends PostHogCoreStateless {
             .catch((e) => {
             cb?.(e, undefined);
             if (!cb) {
-                this.logMsgIfDebug(() => console.log('[PostHog] Error reloading feature flags', e));
+                this.logMsgIfDebug(() => console.log('PostHog Debug', 'Error reloading feature flags', e));
             }
         });
     }
@@ -2503,8 +2706,6 @@ class PostHogCore extends PostHogCoreStateless {
     }
 }
 
-var version = "3.5.0";
-
 function getContext(window) {
   let context = {};
   if (window?.navigator) {
@@ -2808,39 +3009,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
-    }
+// import { patch } from 'rrweb/typings/utils'
+// copied from: https://github.com/PostHog/posthog-js/blob/main/src/extensions/replay/rrweb-plugins/patch.ts
+// which was copied from https://github.com/rrweb-io/rrweb/blob/8aea5b00a4dfe5a6f59bd2ae72bb624f45e51e81/packages/rrweb/src/utils.ts#L129
+// which was copied from https://github.com/getsentry/sentry-javascript/blob/b2109071975af8bf0316d3b5b38f519bdaf5dc15/packages/utils/src/object.ts
+// 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';
+};
+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 {
@@ -2947,4 +3154,4 @@ class PostHog extends PostHogCore {
 
 exports.PostHog = PostHog;
 exports["default"] = PostHog;
-//# sourceMappingURL=index.cjs.js.map
+//# sourceMappingURL=index.cjs.map