@posthog/core 1.0.2 → 1.2.0

package/dist/posthog-core.mjs

@@ -0,0 +1,520 @@
+import { createFlagsResponseFromFlagsAndPayloads, getFeatureFlagValue, getFlagValuesFromFlags, getPayloadsFromFlags, normalizeFlagsResponse, updateFlagValue } from "./featureFlagUtils.mjs";
+import { Compression, PostHogPersistedProperty } from "./types.mjs";
+import { PostHogCoreStateless, QuotaLimitedFeature, maybeAdd } from "./posthog-core-stateless.mjs";
+import { uuidv7 } from "./vendor/uuidv7.mjs";
+import { isPlainError } from "./utils/index.mjs";
+class PostHogCore extends PostHogCoreStateless {
+    constructor(apiKey, options){
+        const disableGeoipOption = options?.disableGeoip ?? false;
+        const featureFlagsRequestTimeoutMs = options?.featureFlagsRequestTimeoutMs ?? 10000;
+        super(apiKey, {
+            ...options,
+            disableGeoip: disableGeoipOption,
+            featureFlagsRequestTimeoutMs
+        }), this.flagCallReported = {}, this._sessionMaxLengthSeconds = 86400, this.sessionProps = {};
+        this.sendFeatureFlagEvent = options?.sendFeatureFlagEvent ?? true;
+        this._sessionExpirationTimeSeconds = options?.sessionExpirationTimeSeconds ?? 1800;
+    }
+    setupBootstrap(options) {
+        const bootstrap = options?.bootstrap;
+        if (!bootstrap) return;
+        if (bootstrap.distinctId) if (bootstrap.isIdentifiedId) {
+            const distinctId = this.getPersistedProperty(PostHogPersistedProperty.DistinctId);
+            if (!distinctId) this.setPersistedProperty(PostHogPersistedProperty.DistinctId, bootstrap.distinctId);
+        } else {
+            const anonymousId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+            if (!anonymousId) this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, bootstrap.distinctId);
+        }
+        const bootstrapFeatureFlags = bootstrap.featureFlags;
+        const bootstrapFeatureFlagPayloads = bootstrap.featureFlagPayloads ?? {};
+        if (bootstrapFeatureFlags && Object.keys(bootstrapFeatureFlags).length) {
+            const normalizedBootstrapFeatureFlagDetails = createFlagsResponseFromFlagsAndPayloads(bootstrapFeatureFlags, bootstrapFeatureFlagPayloads);
+            if (Object.keys(normalizedBootstrapFeatureFlagDetails.flags).length > 0) {
+                this.setBootstrappedFeatureFlagDetails(normalizedBootstrapFeatureFlagDetails);
+                const currentFeatureFlagDetails = this.getKnownFeatureFlagDetails() || {
+                    flags: {},
+                    requestId: void 0
+                };
+                const newFeatureFlagDetails = {
+                    flags: {
+                        ...normalizedBootstrapFeatureFlagDetails.flags,
+                        ...currentFeatureFlagDetails.flags
+                    },
+                    requestId: normalizedBootstrapFeatureFlagDetails.requestId
+                };
+                this.setKnownFeatureFlagDetails(newFeatureFlagDetails);
+            }
+        }
+    }
+    clearProps() {
+        this.props = void 0;
+        this.sessionProps = {};
+        this.flagCallReported = {};
+    }
+    on(event, cb) {
+        return this._events.on(event, cb);
+    }
+    reset(propertiesToKeep) {
+        this.wrap(()=>{
+            const allPropertiesToKeep = [
+                PostHogPersistedProperty.Queue,
+                ...propertiesToKeep || []
+            ];
+            this.clearProps();
+            for (const key of Object.keys(PostHogPersistedProperty))if (!allPropertiesToKeep.includes(PostHogPersistedProperty[key])) this.setPersistedProperty(PostHogPersistedProperty[key], null);
+            this.reloadFeatureFlags();
+        });
+    }
+    getCommonEventProperties() {
+        const featureFlags = this.getFeatureFlags();
+        const featureVariantProperties = {};
+        if (featureFlags) for (const [feature, variant] of Object.entries(featureFlags))featureVariantProperties[`$feature/${feature}`] = variant;
+        return {
+            ...maybeAdd('$active_feature_flags', featureFlags ? Object.keys(featureFlags) : void 0),
+            ...featureVariantProperties,
+            ...super.getCommonEventProperties()
+        };
+    }
+    enrichProperties(properties) {
+        return {
+            ...this.props,
+            ...this.sessionProps,
+            ...properties || {},
+            ...this.getCommonEventProperties(),
+            $session_id: this.getSessionId()
+        };
+    }
+    getSessionId() {
+        if (!this._isInitialized) return '';
+        let sessionId = this.getPersistedProperty(PostHogPersistedProperty.SessionId);
+        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 > 1000 * this._sessionExpirationTimeSeconds || sessionStartDif > 1000 * this._sessionMaxLengthSeconds) {
+            sessionId = uuidv7();
+            this.setPersistedProperty(PostHogPersistedProperty.SessionId, sessionId);
+            this.setPersistedProperty(PostHogPersistedProperty.SessionStartTimestamp, 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);
+        });
+    }
+    getAnonymousId() {
+        if (!this._isInitialized) return '';
+        let anonId = this.getPersistedProperty(PostHogPersistedProperty.AnonymousId);
+        if (!anonId) {
+            anonId = uuidv7();
+            this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, anonId);
+        }
+        return anonId;
+    }
+    getDistinctId() {
+        if (!this._isInitialized) return '';
+        return this.getPersistedProperty(PostHogPersistedProperty.DistinctId) || this.getAnonymousId();
+    }
+    registerForSession(properties) {
+        this.sessionProps = {
+            ...this.sessionProps,
+            ...properties
+        };
+    }
+    unregisterForSession(property) {
+        delete this.sessionProps[property];
+    }
+    identify(distinctId, properties, options) {
+        this.wrap(()=>{
+            const previousDistinctId = this.getDistinctId();
+            distinctId = distinctId || previousDistinctId;
+            if (properties?.$groups) this.groups(properties.$groups);
+            const userPropsOnce = properties?.$set_once;
+            delete properties?.$set_once;
+            const userProps = properties?.$set || properties;
+            const allProperties = this.enrichProperties({
+                $anon_distinct_id: this.getAnonymousId(),
+                ...maybeAdd('$set', userProps),
+                ...maybeAdd('$set_once', userPropsOnce)
+            });
+            if (distinctId !== previousDistinctId) {
+                this.setPersistedProperty(PostHogPersistedProperty.AnonymousId, previousDistinctId);
+                this.setPersistedProperty(PostHogPersistedProperty.DistinctId, distinctId);
+                this.reloadFeatureFlags();
+            }
+            super.identifyStateless(distinctId, allProperties, options);
+        });
+    }
+    capture(event, properties, options) {
+        this.wrap(()=>{
+            const distinctId = this.getDistinctId();
+            if (properties?.$groups) this.groups(properties.$groups);
+            const allProperties = this.enrichProperties(properties);
+            super.captureStateless(distinctId, event, allProperties, options);
+        });
+    }
+    alias(alias) {
+        this.wrap(()=>{
+            const distinctId = this.getDistinctId();
+            const allProperties = this.enrichProperties({});
+            super.aliasStateless(alias, distinctId, allProperties);
+        });
+    }
+    autocapture(eventType, elements, properties = {}, options) {
+        this.wrap(()=>{
+            const distinctId = this.getDistinctId();
+            const payload = {
+                distinct_id: distinctId,
+                event: '$autocapture',
+                properties: {
+                    ...this.enrichProperties(properties),
+                    $event_type: eventType,
+                    $elements: elements
+                }
+            };
+            this.enqueue('autocapture', payload, options);
+        });
+    }
+    groups(groups) {
+        this.wrap(()=>{
+            const existingGroups = this.props.$groups || {};
+            this.register({
+                $groups: {
+                    ...existingGroups,
+                    ...groups
+                }
+            });
+            if (Object.keys(groups).find((type)=>existingGroups[type] !== groups[type])) this.reloadFeatureFlags();
+        });
+    }
+    group(groupType, groupKey, groupProperties, options) {
+        this.wrap(()=>{
+            this.groups({
+                [groupType]: groupKey
+            });
+            if (groupProperties) this.groupIdentify(groupType, groupKey, groupProperties, options);
+        });
+    }
+    groupIdentify(groupType, groupKey, groupProperties, options) {
+        this.wrap(()=>{
+            const distinctId = this.getDistinctId();
+            const eventProperties = this.enrichProperties({});
+            super.groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties);
+        });
+    }
+    setPersonPropertiesForFlags(properties) {
+        this.wrap(()=>{
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, {
+                ...existingProperties,
+                ...properties
+            });
+        });
+    }
+    resetPersonPropertiesForFlags() {
+        this.wrap(()=>{
+            this.setPersistedProperty(PostHogPersistedProperty.PersonProperties, null);
+        });
+    }
+    setGroupPropertiesForFlags(properties) {
+        this.wrap(()=>{
+            const existingProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
+            if (0 !== Object.keys(existingProperties).length) Object.keys(existingProperties).forEach((groupType)=>{
+                existingProperties[groupType] = {
+                    ...existingProperties[groupType],
+                    ...properties[groupType]
+                };
+                delete properties[groupType];
+            });
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, {
+                ...existingProperties,
+                ...properties
+            });
+        });
+    }
+    resetGroupPropertiesForFlags() {
+        this.wrap(()=>{
+            this.setPersistedProperty(PostHogPersistedProperty.GroupProperties, null);
+        });
+    }
+    async remoteConfigAsync() {
+        await this._initPromise;
+        if (this._remoteConfigResponsePromise) return this._remoteConfigResponsePromise;
+        return this._remoteConfigAsync();
+    }
+    async flagsAsync(sendAnonDistinctId = true) {
+        await this._initPromise;
+        if (this._flagsResponsePromise) return this._flagsResponsePromise;
+        return this._flagsAsync(sendAnonDistinctId);
+    }
+    cacheSessionReplay(source, response) {
+        const sessionReplay = response?.sessionRecording;
+        if (sessionReplay) {
+            this.setPersistedProperty(PostHogPersistedProperty.SessionReplay, sessionReplay);
+            this.logMsgIfDebug(()=>console.log('PostHog Debug', `Session replay config from ${source}: `, JSON.stringify(sessionReplay)));
+        } else if ('boolean' == typeof sessionReplay && false === sessionReplay) {
+            this.logMsgIfDebug(()=>console.info('PostHog Debug', `Session replay config from ${source} 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)));
+                    if (false === this.disableSurveys) {
+                        const surveys = response.surveys;
+                        let hasSurveys = true;
+                        if (Array.isArray(surveys)) this.logMsgIfDebug(()=>console.log('PostHog Debug', 'Surveys fetched from remote config: ', JSON.stringify(surveys)));
+                        else {
+                            this.logMsgIfDebug(()=>console.log('PostHog Debug', 'There are no surveys.'));
+                            hasSurveys = false;
+                        }
+                        if (hasSurveys) this.setPersistedProperty(PostHogPersistedProperty.Surveys, surveys);
+                        else this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                    } else this.setPersistedProperty(PostHogPersistedProperty.Surveys, null);
+                    this.setPersistedProperty(PostHogPersistedProperty.RemoteConfig, remoteConfigWithoutSurveys);
+                    this.cacheSessionReplay('remote config', response);
+                    if (false === response.hasFeatureFlags) {
+                        this.setKnownFeatureFlagDetails({
+                            flags: {}
+                        });
+                        this.logMsgIfDebug(()=>console.warn('Remote config has no feature flags, will not load feature flags.'));
+                    } else if (false !== this.preloadFeatureFlags) this.reloadFeatureFlags();
+                    if (!response.supportedCompression?.includes(Compression.GZipJS)) this.disableCompression = true;
+                    remoteConfig = response;
+                }
+                return remoteConfig;
+            });
+        }).finally(()=>{
+            this._remoteConfigResponsePromise = void 0;
+        });
+        return this._remoteConfigResponsePromise;
+    }
+    async _flagsAsync(sendAnonDistinctId = true) {
+        this._flagsResponsePromise = this._initPromise.then(async ()=>{
+            const distinctId = this.getDistinctId();
+            const groups = this.props.$groups || {};
+            const personProperties = this.getPersistedProperty(PostHogPersistedProperty.PersonProperties) || {};
+            const groupProperties = this.getPersistedProperty(PostHogPersistedProperty.GroupProperties) || {};
+            const extraProperties = {
+                $anon_distinct_id: sendAnonDistinctId ? this.getAnonymousId() : void 0
+            };
+            const res = await super.getFlags(distinctId, groups, personProperties, groupProperties, extraProperties);
+            if (res?.quotaLimited?.includes(QuotaLimitedFeature.FeatureFlags)) {
+                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) {
+                if (this.sendFeatureFlagEvent) this.flagCallReported = {};
+                let newFeatureFlagDetails = res;
+                if (res.errorsWhileComputingFlags) {
+                    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);
+                this.setPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit, true);
+                this.cacheSessionReplay('flags', res);
+            }
+            return res;
+        }).finally(()=>{
+            this._flagsResponsePromise = void 0;
+        });
+        return this._flagsResponsePromise;
+    }
+    setKnownFeatureFlagDetails(flagsResponse) {
+        this.wrap(()=>{
+            this.setPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails, flagsResponse);
+            this._events.emit('featureflags', getFlagValuesFromFlags(flagsResponse?.flags ?? {}));
+        });
+    }
+    getKnownFeatureFlagDetails() {
+        const storedDetails = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagDetails);
+        if (!storedDetails) {
+            const featureFlags = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlags);
+            const featureFlagPayloads = this.getPersistedProperty(PostHogPersistedProperty.FeatureFlagPayloads);
+            if (void 0 === featureFlags && void 0 === featureFlagPayloads) return;
+            return createFlagsResponseFromFlagsAndPayloads(featureFlags ?? {}, featureFlagPayloads ?? {});
+        }
+        return normalizeFlagsResponse(storedDetails);
+    }
+    getKnownFeatureFlags() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) return;
+        return getFlagValuesFromFlags(featureFlagDetails.flags);
+    }
+    getKnownFeatureFlagPayloads() {
+        const featureFlagDetails = this.getKnownFeatureFlagDetails();
+        if (!featureFlagDetails) return;
+        return getPayloadsFromFlags(featureFlagDetails.flags);
+    }
+    getBootstrappedFeatureFlagDetails() {
+        const details = this.getPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails);
+        if (!details) return;
+        return details;
+    }
+    setBootstrappedFeatureFlagDetails(details) {
+        this.setPersistedProperty(PostHogPersistedProperty.BootstrapFeatureFlagDetails, details);
+    }
+    getBootstrappedFeatureFlags() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) return;
+        return getFlagValuesFromFlags(details.flags);
+    }
+    getBootstrappedFeatureFlagPayloads() {
+        const details = this.getBootstrappedFeatureFlagDetails();
+        if (!details) return;
+        return getPayloadsFromFlags(details.flags);
+    }
+    getFeatureFlag(key) {
+        const details = this.getFeatureFlagDetails();
+        if (!details) return;
+        const featureFlag = details.flags[key];
+        let response = getFeatureFlagValue(featureFlag);
+        if (void 0 === response) 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,
+                ...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),
+                $used_bootstrap_value: !this.getPersistedProperty(PostHogPersistedProperty.FlagsEndpointWasHit),
+                ...maybeAdd('$feature_flag_request_id', details.requestId)
+            });
+        }
+        return response;
+    }
+    getFeatureFlagPayload(key) {
+        const payloads = this.getFeatureFlagPayloads();
+        if (!payloads) return;
+        const response = payloads[key];
+        if (void 0 === response) return null;
+        return response;
+    }
+    getFeatureFlagPayloads() {
+        return this.getFeatureFlagDetails()?.featureFlagPayloads;
+    }
+    getFeatureFlags() {
+        return this.getFeatureFlagDetails()?.featureFlags;
+    }
+    getFeatureFlagDetails() {
+        let details = this.getKnownFeatureFlagDetails();
+        const overriddenFlags = this.getPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags);
+        if (!overriddenFlags) return details;
+        details = details ?? {
+            featureFlags: {},
+            featureFlagPayloads: {},
+            flags: {}
+        };
+        const flags = details.flags ?? {};
+        for(const key in overriddenFlags)if (overriddenFlags[key]) flags[key] = updateFlagValue(flags[key], overriddenFlags[key]);
+        else delete flags[key];
+        const result = {
+            ...details,
+            flags
+        };
+        return normalizeFlagsResponse(result);
+    }
+    getFeatureFlagsAndPayloads() {
+        const flags = this.getFeatureFlags();
+        const payloads = this.getFeatureFlagPayloads();
+        return {
+            flags,
+            payloads
+        };
+    }
+    isFeatureEnabled(key) {
+        const response = this.getFeatureFlag(key);
+        if (void 0 === response) return;
+        return !!response;
+    }
+    reloadFeatureFlags(options) {
+        this.flagsAsync(true).then((res)=>{
+            options?.cb?.(void 0, res?.featureFlags);
+        }).catch((e)=>{
+            options?.cb?.(e, void 0);
+            if (!options?.cb) this.logMsgIfDebug(()=>console.log('PostHog Debug', 'Error reloading feature flags', e));
+        });
+    }
+    async reloadRemoteConfigAsync() {
+        return await this.remoteConfigAsync();
+    }
+    async reloadFeatureFlagsAsync(sendAnonDistinctId) {
+        return (await this.flagsAsync(sendAnonDistinctId ?? true))?.featureFlags;
+    }
+    onFeatureFlags(cb) {
+        return this.on('featureflags', async ()=>{
+            const flags = this.getFeatureFlags();
+            if (flags) cb(flags);
+        });
+    }
+    onFeatureFlag(key, cb) {
+        return this.on('featureflags', async ()=>{
+            const flagResponse = this.getFeatureFlag(key);
+            if (void 0 !== flagResponse) cb(flagResponse);
+        });
+    }
+    async overrideFeatureFlag(flags) {
+        this.wrap(()=>{
+            if (null === flags) return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, null);
+            return this.setPersistedProperty(PostHogPersistedProperty.OverrideFeatureFlags, flags);
+        });
+    }
+    captureException(error, additionalProperties) {
+        const properties = {
+            $exception_level: 'error',
+            $exception_list: [
+                {
+                    type: isPlainError(error) ? error.name : 'Error',
+                    value: isPlainError(error) ? error.message : error,
+                    mechanism: {
+                        handled: true,
+                        synthetic: false
+                    }
+                }
+            ],
+            ...additionalProperties
+        };
+        properties.$exception_personURL = new URL(`/project/${this.apiKey}/person/${this.getDistinctId()}`, this.host).toString();
+        this.capture('$exception', properties);
+    }
+    captureTraceFeedback(traceId, userFeedback) {
+        this.capture('$ai_feedback', {
+            $ai_feedback_text: userFeedback,
+            $ai_trace_id: String(traceId)
+        });
+    }
+    captureTraceMetric(traceId, metricName, metricValue) {
+        this.capture('$ai_metric', {
+            $ai_metric_name: metricName,
+            $ai_metric_value: String(metricValue),
+            $ai_trace_id: String(traceId)
+        });
+    }
+}
+export { PostHogCore };

package/dist/testing/PostHogCoreTestClient.d.ts

@@ -1,4 +1,5 @@
-import { JsonType, PostHogCore, PostHogCoreOptions, PostHogFetchOptions, PostHogFetchResponse, PostHogFlagsResponse } from '../../src';
+import { PostHogCore } from '../posthog-core';
+import type { JsonType, PostHogCoreOptions, PostHogFetchOptions, PostHogFetchResponse, PostHogFlagsResponse } from '../types';
 export interface PostHogCoreTestClientMocks {
     fetch: jest.Mock<Promise<PostHogFetchResponse>, [string, PostHogFetchOptions]>;
     storage: {

package/dist/testing/PostHogCoreTestClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PostHogCoreTestClient.d.ts","sourceRoot":"","sources":["../../src/testing/PostHogCoreTestClient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,WAAW,EACX,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,WAAW,CAAA;AAIlB,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAA;IAC9E,OAAO,EAAE;QACP,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC,CAAA;KAC/C,CAAA;CACF;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IAIlD,OAAO,CAAC,KAAK;IAHR,iBAAiB,CAAC,EAAE,MAAM,CAAA;gBAGvB,KAAK,EAAE,0BAA0B,EACzC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB;IAQvB,QAAQ,CACb,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAM,EAC5C,gBAAgB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAC7C,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,EAC5D,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACrC,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAI5C,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;IAGvC,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;IAG3D,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAG/E,YAAY,IAAI,MAAM;IAGtB,iBAAiB,IAAI,MAAM;IAG3B,kBAAkB,IAAI,MAAM;CAG7B;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,UAAU,kBAAkB,EAC5B,aAAa,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,EACxD,eAAc;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAA;CAAO,KACtD,CAAC,qBAAqB,EAAE,0BAA0B,CAsBpD,CAAA"}
+{"version":3,"file":"PostHogCoreTestClient.d.ts","sourceRoot":"","sources":["../../src/testing/PostHogCoreTestClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAIhB,MAAM,WAAW,0BAA0B;IACzC,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAA;IAC9E,OAAO,EAAE;QACP,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC,CAAA;KAC/C,CAAA;CACF;AAED,qBAAa,qBAAsB,SAAQ,WAAW;IAIlD,OAAO,CAAC,KAAK;IAHR,iBAAiB,CAAC,EAAE,MAAM,CAAA;gBAGvB,KAAK,EAAE,0BAA0B,EACzC,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,kBAAkB;IAQvB,QAAQ,CACb,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAM,EAC5C,gBAAgB,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,EAC7C,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,EAC5D,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACrC,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAI5C,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC;IAGvC,oBAAoB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI;IAG3D,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAG/E,YAAY,IAAI,MAAM;IAGtB,iBAAiB,IAAI,MAAM;IAG3B,kBAAkB,IAAI,MAAM;CAG7B;AAED,eAAO,MAAM,gBAAgB,GAC3B,QAAQ,MAAM,EACd,UAAU,kBAAkB,EAC5B,aAAa,CAAC,KAAK,EAAE,0BAA0B,KAAK,IAAI,EACxD,eAAc;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAA;CAAO,KACtD,CAAC,qBAAqB,EAAE,0BAA0B,CAsBpD,CAAA"}

package/dist/testing/PostHogCoreTestClient.js

@@ -27,11 +27,14 @@ __webpack_require__.d(__webpack_exports__, {
     PostHogCoreTestClient: ()=>PostHogCoreTestClient,
     createTestClient: ()=>createTestClient
 });
-const external_index_js_namespaceObject = require("../index.js");
+const external_posthog_core_js_namespaceObject = require("../posthog-core.js");
 const version = '2.0.0-alpha';
-class PostHogCoreTestClient extends external_index_js_namespaceObject.PostHogCore {
-    getFlags(distinctId) {
-        let groups = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}, personProperties = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}, groupProperties = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : {}, extraPayload = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : {};
+class PostHogCoreTestClient extends external_posthog_core_js_namespaceObject.PostHogCore {
+    constructor(mocks, apiKey, options){
+        super(apiKey, options), this.mocks = mocks;
+        this.setupBootstrap(options);
+    }
+    getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         return super.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
     }
     getPersistedProperty(key) {
@@ -52,13 +55,8 @@ class PostHogCoreTestClient extends external_index_js_namespaceObject.PostHogCor
     getCustomUserAgent() {
         return 'posthog-core-tests';
     }
-    constructor(mocks, apiKey, options){
-        super(apiKey, options), this.mocks = mocks;
-        this.setupBootstrap(options);
-    }
 }
-const createTestClient = function(apiKey, options, setupMocks) {
-    let storageCache = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : {};
+const createTestClient = (apiKey, options, setupMocks, storageCache = {})=>{
     const mocks = {
         fetch: jest.fn(),
         storage: {
@@ -75,7 +73,7 @@ const createTestClient = function(apiKey, options, setupMocks) {
                     status: 'ok'
                 })
         }));
-    null == setupMocks || setupMocks(mocks);
+    setupMocks?.(mocks);
     return [
         new PostHogCoreTestClient(mocks, apiKey, {
             disableCompression: true,

package/dist/testing/PostHogCoreTestClient.mjs

@@ -1,8 +1,11 @@
-import { PostHogCore } from "../index.mjs";
+import { PostHogCore } from "../posthog-core.mjs";
 const version = '2.0.0-alpha';
 class PostHogCoreTestClient extends PostHogCore {
-    getFlags(distinctId) {
-        let groups = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : {}, personProperties = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : {}, groupProperties = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : {}, extraPayload = arguments.length > 4 && void 0 !== arguments[4] ? arguments[4] : {};
+    constructor(mocks, apiKey, options){
+        super(apiKey, options), this.mocks = mocks;
+        this.setupBootstrap(options);
+    }
+    getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}) {
         return super.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
     }
     getPersistedProperty(key) {
@@ -23,13 +26,8 @@ class PostHogCoreTestClient extends PostHogCore {
     getCustomUserAgent() {
         return 'posthog-core-tests';
     }
-    constructor(mocks, apiKey, options){
-        super(apiKey, options), this.mocks = mocks;
-        this.setupBootstrap(options);
-    }
 }
-const createTestClient = function(apiKey, options, setupMocks) {
-    let storageCache = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : {};
+const createTestClient = (apiKey, options, setupMocks, storageCache = {})=>{
     const mocks = {
         fetch: jest.fn(),
         storage: {
@@ -46,7 +44,7 @@ const createTestClient = function(apiKey, options, setupMocks) {
                     status: 'ok'
                 })
         }));
-    null == setupMocks || setupMocks(mocks);
+    setupMocks?.(mocks);
     return [
         new PostHogCoreTestClient(mocks, apiKey, {
             disableCompression: true,

package/dist/testing/test-utils.d.ts

@@ -1,6 +1,8 @@
+import { Logger } from '../types';
 export declare const wait: (t: number) => Promise<void>;
 export declare const waitForPromises: () => Promise<void>;
 export declare const parseBody: (mockCall: any) => any;
 export declare const createImperativePromise: <T>() => [Promise<T>, (value: T) => void];
 export declare const delay: (ms: number) => Promise<void>;
+export declare const createMockLogger: () => Logger;
 //# sourceMappingURL=test-utils.d.ts.map

package/dist/testing/test-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/testing/test-utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,GAAU,GAAG,MAAM,KAAG,OAAO,CAAC,IAAI,CAElD,CAAA;AAED,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,IAAI,CAQpD,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,GAAG,KAAG,GAIzC,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,CAAC,OAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAM5E,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAI9C,CAAA"}
+{"version":3,"file":"test-utils.d.ts","sourceRoot":"","sources":["../../src/testing/test-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhC,eAAO,MAAM,IAAI,GAAU,GAAG,MAAM,KAAG,OAAO,CAAC,IAAI,CAElD,CAAA;AAED,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,IAAI,CAQpD,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,UAAU,GAAG,KAAG,GAIzC,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAI,CAAC,OAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAM5E,CAAA;AAED,eAAO,MAAM,KAAK,GAAI,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAI9C,CAAA;AAED,eAAO,MAAM,gBAAgB,QAAO,MAUnC,CAAA"}

package/dist/testing/test-utils.js

@@ -25,6 +25,7 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     createImperativePromise: ()=>createImperativePromise,
+    createMockLogger: ()=>createMockLogger,
     delay: ()=>delay,
     parseBody: ()=>parseBody,
     wait: ()=>wait,
@@ -52,19 +53,30 @@ const createImperativePromise = ()=>{
     });
     return [
         promise,
-        (val)=>null == resolve ? void 0 : resolve(val)
+        (val)=>resolve?.(val)
     ];
 };
 const delay = (ms)=>new Promise((resolve)=>{
         setTimeout(resolve, ms);
     });
+const createMockLogger = ()=>({
+        _log: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        critical: jest.fn(),
+        uninitializedWarning: jest.fn(),
+        createLogger: createMockLogger
+    });
 exports.createImperativePromise = __webpack_exports__.createImperativePromise;
+exports.createMockLogger = __webpack_exports__.createMockLogger;
 exports.delay = __webpack_exports__.delay;
 exports.parseBody = __webpack_exports__.parseBody;
 exports.wait = __webpack_exports__.wait;
 exports.waitForPromises = __webpack_exports__.waitForPromises;
 for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "createImperativePromise",
+    "createMockLogger",
     "delay",
     "parseBody",
     "wait",