@posthog/browser-common 0.9.5 → 0.9.6

package/dist/surveys.d.ts

@@ -0,0 +1,117 @@
+export { SurveyEventType, SurveyWidgetType, SurveyPosition, SurveyTabPosition, SurveyType, SurveyQuestionType, SurveyQuestionBranchingType, SurveySchedule, SurveyEventName, SurveyEventProperties, DisplaySurveyType, } from './survey-constants';
+import type { SurveyRenderContext } from './survey-render-context';
+import type { Client } from './client';
+import type { DeepReadonly } from './client';
+import type { Extension } from './extension';
+import type { SurveysEventReceiver } from './surveys-config';
+import { type DisplaySurveyOptions, type Survey, type SurveyCallback, type SurveyRenderReason } from './types/surveys';
+import type { SurveysConfigSource } from './surveys-config';
+import type { Properties } from '@posthog/types';
+import type { RemoteConfigResult } from './types/remote-config';
+export type SurveyFetchResult = {
+    surveys: Survey[];
+    context?: {
+        isLoaded: boolean;
+        error?: string;
+    };
+};
+export declare class PostHogSurveys implements Extension {
+    private readonly _configSource;
+    readonly name: string;
+    private _isSurveysEnabled?;
+    _surveyEventReceiver: SurveysEventReceiver | null;
+    private _surveyManager;
+    private _isInitializingSurveys;
+    private _surveyInitializationFailed;
+    private _surveyCallbacks;
+    private _activeMatchingSurveyCallbacks;
+    private _activeMatchingSurveyConditionsUnsubscribe;
+    private _getSurveysInFlightPromise;
+    private _lastSurveyRefreshFailedAt;
+    private _client;
+    private _initializingClient;
+    private _remoteConfigSubscription;
+    private _disposed;
+    private _renderTimeouts;
+    constructor(_configSource: SurveysConfigSource);
+    setup(client: Client): void | Promise<void>;
+    dispose(): void;
+    private get _config();
+    getRenderContext(): SurveyRenderContext | undefined;
+    initialize(): void;
+    onRemoteConfig: (result: DeepReadonly<RemoteConfigResult>) => void;
+    reset(): void;
+    loadIfEnabled(): void;
+    /** Helper to finalize survey initialization */
+    private _completeSurveyInitialization;
+    /** Helper to handle errors during survey loading */
+    private _handleSurveyLoadError;
+    /**
+     * Register a callback that runs when surveys are initialized.
+     * ### Usage:
+     *
+     *     posthog.onSurveysLoaded((surveys) => {
+     *         // You can work with all surveys
+     *         console.log('All available surveys:', surveys)
+     *
+     *         // Or get active matching surveys
+     *         posthog.getActiveMatchingSurveys((activeMatchingSurveys) => {
+     *             if (activeMatchingSurveys.length > 0) {
+     *                 posthog.renderSurvey(activeMatchingSurveys[0].id, '#survey-container')
+     *             }
+     *         })
+     *     })
+     *
+     * @param {Function} callback The callback function will be called when surveys are loaded or updated.
+     *                           It receives the array of all surveys and a context object with error status.
+     * @returns {Function} A function that can be called to unsubscribe the listener.
+     */
+    onSurveysLoaded(callback: SurveyCallback): () => void;
+    getSurveys(callback: SurveyCallback, forceReload?: boolean): void;
+    private _handleSurveyResponse;
+    private _registerEventOrActionBasedSurveys;
+    /**
+     * Whether to kick off a background refresh of the cached definitions: the cache is stale, no
+     * fetch is already in flight, and we're not backing off after a recent failure.
+     */
+    private _shouldBackgroundRefreshSurveys;
+    /**
+     * Whether the cached `$surveys` definitions have aged past their TTL. Returns false when no
+     * timestamp is recorded (e.g. surveys injected directly in tests) so the cache stays valid.
+     */
+    private _isSurveyCacheStale;
+    private _isSurveyRefreshBackingOff;
+    /**
+     * Marks a survey as seen for the current device, mirroring the local state the SDK records
+     * when it shows or sends a survey itself.
+     *
+     * Use this when you display surveys through your own backend/integration (so the SDK never
+     * captures the `survey shown`/`sent`/`dismissed` events) and still want PostHog's display
+     * logic to honour the "already seen" and wait-period checks on subsequent page loads.
+     *
+     * Note: surveys configured to repeat (`schedule: 'always'` or event `repeatedActivation`)
+     * intentionally bypass the seen check, so marking them as seen will not stop them showing.
+     *
+     * @param surveyId The ID of the survey to mark as seen.
+     * @param options Optional settings. `iteration` is the survey's current iteration number, if any.
+     */
+    markSurveyAsSeen(surveyId: string, options?: {
+        iteration?: number | null;
+    }): void;
+    /** Helper method to notify all registered callbacks */
+    private _notifySurveyCallbacks;
+    getActiveMatchingSurveys(callback: SurveyCallback, forceReload?: boolean): void;
+    onActiveMatchingSurveysChanged(callback: SurveyCallback): () => void;
+    private _startActiveMatchingSurveyConditions;
+    private _notifyActiveMatchingSurveyCallback;
+    private _notifyActiveMatchingSurveyCallbacks;
+    private _getSurveyById;
+    private _checkSurveyEligibility;
+    private _checkSurveyRenderability;
+    canRenderSurvey(surveyId: string | Survey): SurveyRenderReason;
+    canRenderSurveyAsync(surveyId: string, forceReload: boolean): Promise<SurveyRenderReason>;
+    renderSurvey(surveyId: string | Survey, selector: string, properties?: Properties): void;
+    displaySurvey(surveyId: string, options: DisplaySurveyOptions): void;
+    cancelPendingSurvey(surveyId: string): void;
+    handlePageUnload(): void;
+}

package/dist/surveys.js

@@ -0,0 +1,566 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DisplaySurveyType: ()=>external_survey_constants_js_namespaceObject.DisplaySurveyType,
+    PostHogSurveys: ()=>PostHogSurveys,
+    SurveyEventName: ()=>external_survey_constants_js_namespaceObject.SurveyEventName,
+    SurveyEventProperties: ()=>external_survey_constants_js_namespaceObject.SurveyEventProperties,
+    SurveyEventType: ()=>external_survey_constants_js_namespaceObject.SurveyEventType,
+    SurveyPosition: ()=>external_survey_constants_js_namespaceObject.SurveyPosition,
+    SurveyQuestionBranchingType: ()=>external_survey_constants_js_namespaceObject.SurveyQuestionBranchingType,
+    SurveyQuestionType: ()=>external_survey_constants_js_namespaceObject.SurveyQuestionType,
+    SurveySchedule: ()=>external_survey_constants_js_namespaceObject.SurveySchedule,
+    SurveyTabPosition: ()=>external_survey_constants_js_namespaceObject.SurveyTabPosition,
+    SurveyType: ()=>external_survey_constants_js_namespaceObject.SurveyType,
+    SurveyWidgetType: ()=>external_survey_constants_js_namespaceObject.SurveyWidgetType
+});
+const external_survey_constants_js_namespaceObject = require("./survey-constants.js");
+const external_survey_event_receiver_js_namespaceObject = require("./survey-event-receiver.js");
+const promise_utils_js_namespaceObject = require("./utils/promise-utils.js");
+const core_namespaceObject = require("@posthog/core");
+const external_surveys_config_js_namespaceObject = require("./surveys-config.js");
+const survey_utils_js_namespaceObject = require("./utils/survey-utils.js");
+const SURVEY_NOT_LOADED = 'SDK is not enabled or survey functionality is not yet loaded';
+const SURVEY_DISABLED = 'Disabled. Not loading surveys.';
+class PostHogSurveys {
+    constructor(_configSource){
+        this._configSource = _configSource;
+        this.name = 'surveys';
+        this._surveyEventReceiver = null;
+        this._surveyManager = null;
+        this._isInitializingSurveys = false;
+        this._surveyInitializationFailed = false;
+        this._surveyCallbacks = [];
+        this._activeMatchingSurveyCallbacks = [];
+        this._getSurveysInFlightPromise = null;
+        this._lastSurveyRefreshFailedAt = null;
+        this._disposed = false;
+        this._renderTimeouts = new Set();
+        this.onRemoteConfig = (result)=>{
+            if (this._disposed) return;
+            if (this._config.disableSurveys) return;
+            if (!result.ok) {
+                this._surveyInitializationFailed = true;
+                this._notifyActiveMatchingSurveyCallbacks({
+                    isLoaded: false,
+                    error: 'Remote config unavailable. Not loading surveys.'
+                });
+                return survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Remote config unavailable. Not loading surveys.');
+            }
+            const surveys = result.config['surveys'];
+            if ((0, core_namespaceObject.isNullish)(surveys)) return survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Flags not loaded yet. Not loading surveys.');
+            this._isSurveysEnabled = (0, core_namespaceObject.isBoolean)(surveys) ? surveys : surveys.length > 0;
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.info(`flags response received, isSurveysEnabled: ${this._isSurveysEnabled}`);
+            this.loadIfEnabled();
+        };
+        this._notifyActiveMatchingSurveyCallbacks = (context)=>{
+            this._activeMatchingSurveyCallbacks.slice().forEach((subscription)=>this._notifyActiveMatchingSurveyCallback(subscription, context));
+        };
+    }
+    setup(client) {
+        if (this._disposed) return;
+        this._initializingClient = client;
+        return (0, promise_utils_js_namespaceObject.continueWith)(client.kv.initialize(), ()=>{
+            if (this._initializingClient !== client || this._disposed) return;
+            this._initializingClient = void 0;
+            this._client = client;
+            const subscription = client.onRemoteConfig(this.onRemoteConfig);
+            if (this._disposed) return void subscription.dispose();
+            this._remoteConfigSubscription = subscription;
+            this.loadIfEnabled();
+        });
+    }
+    dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        this._initializingClient = void 0;
+        this._client = void 0;
+        this._remoteConfigSubscription?.dispose();
+        this._remoteConfigSubscription = void 0;
+        this._surveyEventReceiver?.dispose();
+        this._surveyEventReceiver = null;
+        this._surveyManager?.dispose?.();
+        this._surveyManager = null;
+        this._surveyCallbacks = [];
+        this._activeMatchingSurveyCallbacks.forEach((subscription)=>{
+            subscription.active = false;
+        });
+        this._activeMatchingSurveyCallbacks = [];
+        this._activeMatchingSurveyConditionsUnsubscribe?.();
+        this._activeMatchingSurveyConditionsUnsubscribe = void 0;
+        this._getSurveysInFlightPromise = null;
+        this._renderTimeouts.forEach((timeout)=>clearTimeout(timeout));
+        this._renderTimeouts.clear();
+    }
+    get _config() {
+        return this._configSource.get();
+    }
+    getRenderContext() {
+        if (!this._client) return;
+        const surveys = this;
+        return {
+            client: this._client,
+            get config () {
+                return surveys._config;
+            },
+            surveys
+        };
+    }
+    initialize() {
+        this.loadIfEnabled();
+    }
+    reset() {
+        this._surveyManager?.clearInMemoryInProgressSurveyState?.();
+        try {
+            this._surveyEventReceiver?.reset();
+            localStorage.removeItem('lastSeenSurveyDate');
+            const surveyKeys = [];
+            for(let i = 0; i < localStorage.length; i++){
+                const key = localStorage.key(i);
+                if (key?.startsWith(survey_utils_js_namespaceObject.SURVEY_SEEN_PREFIX) || key?.startsWith(survey_utils_js_namespaceObject.SURVEY_IN_PROGRESS_PREFIX)) surveyKeys.push(key);
+            }
+            surveyKeys.forEach((key)=>localStorage.removeItem(key));
+        } catch  {}
+        this._notifyActiveMatchingSurveyCallbacks();
+    }
+    loadIfEnabled() {
+        if (this._disposed || !this._client) return;
+        const config = this._config;
+        if (this._surveyManager) return;
+        if (this._isInitializingSurveys) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.info('Already initializing surveys, skipping...');
+        if (config.disableSurveys) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.info(SURVEY_DISABLED);
+        if (config.cookielessMode && this._client.isOptedOut) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.info('Not loading surveys in cookieless mode without consent.');
+        const phExtensions = this._configSource.getExtensions();
+        if (!phExtensions) return void this._handleSurveyLoadError('PostHog Extensions not found.');
+        if ((0, core_namespaceObject.isUndefined)(this._isSurveysEnabled) && !config.advancedEnableSurveys) return;
+        const isSurveysEnabled = this._isSurveysEnabled || config.advancedEnableSurveys;
+        this._isInitializingSurveys = true;
+        this._surveyInitializationFailed = false;
+        try {
+            const generateSurveys = phExtensions.generateSurveys;
+            if (generateSurveys) {
+                this._completeSurveyInitialization(generateSurveys, isSurveysEnabled);
+                this._isInitializingSurveys = false;
+                return;
+            }
+            const loadExternalDependency = phExtensions.loadExternalDependency;
+            if (!loadExternalDependency) {
+                this._handleSurveyLoadError(external_surveys_config_js_namespaceObject.LOAD_EXT_NOT_FOUND);
+                this._isInitializingSurveys = false;
+                return;
+            }
+            loadExternalDependency((err)=>{
+                try {
+                    if (this._disposed) return;
+                    const loadedExtensions = this._configSource.getExtensions();
+                    if (err || !loadedExtensions?.generateSurveys) this._handleSurveyLoadError("Could not load surveys script", err);
+                    else this._completeSurveyInitialization(loadedExtensions.generateSurveys, isSurveysEnabled);
+                } finally{
+                    this._isInitializingSurveys = false;
+                }
+            });
+        } catch (e) {
+            this._isInitializingSurveys = false;
+            this._handleSurveyLoadError('Error initializing surveys', e);
+            throw e;
+        }
+    }
+    _completeSurveyInitialization(generateSurveysFn, isSurveysEnabled) {
+        if (this._disposed) return;
+        this._surveyManager = generateSurveysFn(isSurveysEnabled);
+        this._surveyEventReceiver = new external_survey_event_receiver_js_namespaceObject.SurveyEventReceiver(this._client, this, this._notifyActiveMatchingSurveyCallbacks);
+        const cachedSurveys = this._client?.kv.get(external_surveys_config_js_namespaceObject.SURVEYS);
+        if (cachedSurveys) this._registerEventOrActionBasedSurveys(cachedSurveys);
+        survey_utils_js_namespaceObject.SURVEY_LOGGER.info('Surveys loaded successfully');
+        this._startActiveMatchingSurveyConditions();
+        this._notifyActiveMatchingSurveyCallbacks();
+        this._notifySurveyCallbacks({
+            isLoaded: true
+        });
+    }
+    _handleSurveyLoadError(message, error) {
+        this._surveyInitializationFailed = true;
+        survey_utils_js_namespaceObject.SURVEY_LOGGER.error(message, error);
+        this._notifyActiveMatchingSurveyCallbacks({
+            isLoaded: false,
+            error: message
+        });
+        this._notifySurveyCallbacks({
+            isLoaded: false,
+            error: message
+        });
+    }
+    onSurveysLoaded(callback) {
+        this._surveyCallbacks.push(callback);
+        if (this._surveyManager) this._notifySurveyCallbacks({
+            isLoaded: true
+        });
+        return ()=>{
+            this._surveyCallbacks = this._surveyCallbacks.filter((cb)=>cb !== callback);
+        };
+    }
+    getSurveys(callback, forceReload = false) {
+        if (this._disposed) return;
+        const client = this._client;
+        if (!client) return callback([], {
+            isLoaded: false,
+            error: SURVEY_NOT_LOADED
+        });
+        if (this._config.disableSurveys) {
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.info(SURVEY_DISABLED);
+            return callback([]);
+        }
+        const surveys = client.kv.get(external_surveys_config_js_namespaceObject.SURVEYS);
+        if (surveys && !forceReload) {
+            callback(surveys, {
+                isLoaded: true
+            });
+            if (this._shouldBackgroundRefreshSurveys()) this.getSurveys(()=>{}, true);
+            return;
+        }
+        if (this._getSurveysInFlightPromise) return void this._getSurveysInFlightPromise.then(({ surveys, context })=>{
+            if (!this._disposed) callback(surveys, context);
+        }).catch((error)=>survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error in survey callback', error));
+        const request = client.sendRequest('/api/surveys/', {
+            method: 'GET',
+            query: {
+                token: client.projectToken
+            },
+            sentAt: 'query',
+            timeoutMs: this._config.requestTimeoutMs
+        }).then((response)=>{
+            try {
+                return this._handleSurveyResponse(client, response);
+            } catch (error) {
+                survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error processing surveys response', error);
+                return this._handleSurveyResponse(client, {
+                    statusCode: 0,
+                    error
+                });
+            }
+        }, (error)=>this._handleSurveyResponse(client, {
+                statusCode: 0,
+                error
+            }));
+        this._getSurveysInFlightPromise = request;
+        const clearInFlight = ()=>{
+            if (this._getSurveysInFlightPromise === request) this._getSurveysInFlightPromise = null;
+        };
+        request.then((result)=>{
+            clearInFlight();
+            if (!this._disposed) {
+                this._notifyActiveMatchingSurveyCallbacks(result.context);
+                callback(result.surveys, result.context);
+            }
+        }, clearInFlight).catch((error)=>survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error in survey callback', error));
+    }
+    _handleSurveyResponse(client, response) {
+        if (this._disposed) return {
+            surveys: [],
+            context: {
+                isLoaded: false,
+                error: SURVEY_NOT_LOADED
+            }
+        };
+        const statusCode = response.statusCode;
+        if (200 !== statusCode || !response.json) {
+            const error = `Surveys API could not be loaded, status: ${statusCode}`;
+            if (0 !== statusCode) survey_utils_js_namespaceObject.SURVEY_LOGGER.error(error);
+            else if (!response.error) survey_utils_js_namespaceObject.SURVEY_LOGGER.warn(error);
+            this._lastSurveyRefreshFailedAt = Date.now();
+            return {
+                surveys: [],
+                context: {
+                    isLoaded: false,
+                    error
+                }
+            };
+        }
+        this._lastSurveyRefreshFailedAt = null;
+        const surveys = response.json.surveys || [];
+        client.kv.set({
+            [external_surveys_config_js_namespaceObject.SURVEYS]: surveys,
+            [external_surveys_config_js_namespaceObject.SURVEYS_LOADED_AT]: Date.now()
+        });
+        this._registerEventOrActionBasedSurveys(surveys);
+        return {
+            surveys,
+            context: {
+                isLoaded: true
+            }
+        };
+    }
+    _registerEventOrActionBasedSurveys(surveys) {
+        const eventOrActionBasedSurveys = surveys.filter((survey)=>(0, survey_utils_js_namespaceObject.isSurveyRunning)(survey) && ((0, survey_utils_js_namespaceObject.doesSurveyActivateByEvent)(survey) || (0, survey_utils_js_namespaceObject.doesSurveyActivateByAction)(survey)));
+        this._surveyEventReceiver?.replace(eventOrActionBasedSurveys);
+    }
+    _shouldBackgroundRefreshSurveys() {
+        return this._isSurveyCacheStale() && !this._getSurveysInFlightPromise && !this._isSurveyRefreshBackingOff();
+    }
+    _isSurveyCacheStale() {
+        const surveysLoadedAt = this._client?.kv.get(external_surveys_config_js_namespaceObject.SURVEYS_LOADED_AT);
+        return (0, core_namespaceObject.isNumber)(surveysLoadedAt) && Date.now() - surveysLoadedAt > external_surveys_config_js_namespaceObject.SURVEYS_CACHE_TTL_MS;
+    }
+    _isSurveyRefreshBackingOff() {
+        return (0, core_namespaceObject.isNumber)(this._lastSurveyRefreshFailedAt) && Date.now() - this._lastSurveyRefreshFailedAt < external_surveys_config_js_namespaceObject.SURVEYS_REFRESH_BACKOFF_MS;
+    }
+    markSurveyAsSeen(surveyId, options) {
+        const survey = {
+            id: surveyId,
+            current_iteration: options?.iteration ?? null
+        };
+        (0, survey_utils_js_namespaceObject.setSurveySeenOnLocalStorage)(survey);
+        try {
+            localStorage.setItem('lastSeenSurveyDate', new Date().toISOString());
+        } catch  {}
+        this._notifyActiveMatchingSurveyCallbacks();
+    }
+    _notifySurveyCallbacks(context) {
+        for (const callback of this._surveyCallbacks){
+            if (this._disposed) return;
+            try {
+                if (context.isLoaded) this.getSurveys(callback);
+                else callback([], context);
+            } catch (error) {
+                survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error in survey callback', error);
+            }
+        }
+    }
+    getActiveMatchingSurveys(callback, forceReload = false) {
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+        return this._surveyManager.getActiveMatchingSurveys(callback, forceReload);
+    }
+    onActiveMatchingSurveysChanged(callback) {
+        if (this._disposed) return ()=>{};
+        const subscription = {
+            callback,
+            active: true,
+            revision: 0
+        };
+        this._activeMatchingSurveyCallbacks.push(subscription);
+        this._startActiveMatchingSurveyConditions();
+        const cached = this._client?.kv.get(external_surveys_config_js_namespaceObject.SURVEYS);
+        const unavailable = this._config.disableSurveys || !this._surveyManager && this._surveyInitializationFailed && !this._isInitializingSurveys || !cached && !(0, core_namespaceObject.isNullish)(this._lastSurveyRefreshFailedAt) && !this._getSurveysInFlightPromise;
+        if (unavailable) this._notifyActiveMatchingSurveyCallback(subscription, {
+            isLoaded: false
+        });
+        else if (this._surveyManager) this._notifyActiveMatchingSurveyCallback(subscription);
+        return ()=>{
+            subscription.active = false;
+            this._activeMatchingSurveyCallbacks = this._activeMatchingSurveyCallbacks.filter((current)=>current !== subscription);
+            if (0 === this._activeMatchingSurveyCallbacks.length) {
+                this._activeMatchingSurveyConditionsUnsubscribe?.();
+                this._activeMatchingSurveyConditionsUnsubscribe = void 0;
+            }
+        };
+    }
+    _startActiveMatchingSurveyConditions() {
+        if (this._surveyManager && this._activeMatchingSurveyCallbacks.length > 0) this._activeMatchingSurveyConditionsUnsubscribe ??= this._configSource.onMatchingConditionsChanged?.(this._notifyActiveMatchingSurveyCallbacks);
+    }
+    _notifyActiveMatchingSurveyCallback(subscription, context) {
+        if (this._disposed || !subscription.active) return;
+        const revision = ++subscription.revision;
+        const deliver = (surveys)=>{
+            if (this._disposed || !subscription.active || revision !== subscription.revision) return;
+            try {
+                const resultContext = context ?? {
+                    isLoaded: true
+                };
+                const result = JSON.stringify([
+                    surveys,
+                    resultContext
+                ]);
+                if (result === subscription.lastResult) return;
+                subscription.lastResult = result;
+                subscription.callback(surveys, resultContext);
+            } catch (error) {
+                survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error in active matching surveys callback', error);
+            }
+        };
+        try {
+            if (context && !context.isLoaded) deliver([]);
+            else this.getActiveMatchingSurveys(deliver);
+        } catch (error) {
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.error('Error in active matching surveys callback', error);
+        }
+    }
+    _getSurveyById(surveyId) {
+        let survey = null;
+        this.getSurveys((surveys)=>{
+            survey = surveys.find((x)=>x.id === surveyId) ?? null;
+        });
+        return survey;
+    }
+    _checkSurveyEligibility(surveyId) {
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return {
+            eligible: false,
+            reason: SURVEY_NOT_LOADED
+        };
+        const survey = 'string' == typeof surveyId ? this._getSurveyById(surveyId) : surveyId;
+        if (!survey) return {
+            eligible: false,
+            reason: 'Survey not found'
+        };
+        return this._surveyManager.checkSurveyEligibility(survey);
+    }
+    _checkSurveyRenderability(surveyId) {
+        if (!this._client?.canCapture) return {
+            eligible: false,
+            reason: survey_utils_js_namespaceObject.SURVEY_CAPTURING_DISABLED
+        };
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return {
+            eligible: false,
+            reason: SURVEY_NOT_LOADED
+        };
+        const survey = 'string' == typeof surveyId ? this._getSurveyById(surveyId) : surveyId;
+        if (!survey) return {
+            eligible: false,
+            reason: 'Survey not found'
+        };
+        return this._surveyManager.checkSurveyRenderability(survey);
+    }
+    canRenderSurvey(surveyId) {
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) {
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+            return {
+                visible: false,
+                disabledReason: SURVEY_NOT_LOADED
+            };
+        }
+        const eligibility = this._checkSurveyRenderability(surveyId);
+        return {
+            visible: eligibility.eligible,
+            disabledReason: eligibility.reason
+        };
+    }
+    canRenderSurveyAsync(surveyId, forceReload) {
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) {
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+            return Promise.resolve({
+                visible: false,
+                disabledReason: SURVEY_NOT_LOADED
+            });
+        }
+        return new Promise((resolve)=>{
+            this.getSurveys((surveys)=>{
+                const survey = surveys.find((x)=>x.id === surveyId) ?? null;
+                if (survey) {
+                    const eligibility = this._checkSurveyRenderability(survey);
+                    resolve({
+                        visible: eligibility.eligible,
+                        disabledReason: eligibility.reason
+                    });
+                } else resolve({
+                    visible: false,
+                    disabledReason: 'Survey not found'
+                });
+            }, forceReload);
+        });
+    }
+    renderSurvey(surveyId, selector, properties) {
+        if (!this._client?.canCapture) return;
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+        const survey = 'string' == typeof surveyId ? this._getSurveyById(surveyId) : surveyId;
+        if (!survey?.id) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Survey not found');
+        if (!survey_utils_js_namespaceObject.IN_APP_SURVEY_TYPES.includes(survey.type)) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn(`Surveys of type ${survey.type} cannot be rendered in the app`);
+        const elem = ("u" < typeof document ? void 0 : document)?.querySelector(selector);
+        if (!elem) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Survey element not found');
+        if (survey.appearance?.surveyPopupDelaySeconds) {
+            survey_utils_js_namespaceObject.SURVEY_LOGGER.info(`Rendering survey ${survey.id} with delay of ${survey.appearance.surveyPopupDelaySeconds} seconds`);
+            const timeout = setTimeout(()=>{
+                this._renderTimeouts.delete(timeout);
+                if (this._disposed || !this._client?.canCapture) return;
+                survey_utils_js_namespaceObject.SURVEY_LOGGER.info(`Rendering survey ${survey.id} with delay of ${survey.appearance?.surveyPopupDelaySeconds} seconds`);
+                this._surveyManager?.renderSurvey(survey, elem, properties);
+                survey_utils_js_namespaceObject.SURVEY_LOGGER.info(`Survey ${survey.id} rendered`);
+            }, 1000 * survey.appearance.surveyPopupDelaySeconds);
+            this._renderTimeouts.add(timeout);
+            return;
+        }
+        this._surveyManager.renderSurvey(survey, elem, properties);
+    }
+    displaySurvey(surveyId, options) {
+        if (!this._client?.canCapture) return;
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+        const survey = this._getSurveyById(surveyId);
+        if (!survey) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Survey not found');
+        let surveyToDisplay = survey;
+        if (survey.appearance?.surveyPopupDelaySeconds && options.ignoreDelay) surveyToDisplay = {
+            ...survey,
+            appearance: {
+                ...survey.appearance,
+                surveyPopupDelaySeconds: 0
+            }
+        };
+        if (options.displayType !== external_survey_constants_js_namespaceObject.DisplaySurveyType.Popover && options.initialResponses) survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('initialResponses is only supported for popover surveys. prefill will not be applied.');
+        if (false === options.ignoreConditions) {
+            const eligibility = this._checkSurveyEligibility(survey);
+            if (!eligibility.eligible) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('Survey is not eligible to be displayed: ', eligibility.reason);
+        }
+        if (options.displayType === external_survey_constants_js_namespaceObject.DisplaySurveyType.Inline) return void this.renderSurvey(surveyToDisplay, options.selector, options.properties);
+        this._surveyManager.handlePopoverSurvey(surveyToDisplay, options);
+    }
+    cancelPendingSurvey(surveyId) {
+        if ((0, core_namespaceObject.isNullish)(this._surveyManager)) return void survey_utils_js_namespaceObject.SURVEY_LOGGER.warn('init was not called');
+        this._surveyManager.cancelSurvey(surveyId);
+    }
+    handlePageUnload() {
+        this._surveyManager?.handlePageUnload?.();
+    }
+}
+exports.DisplaySurveyType = __webpack_exports__.DisplaySurveyType;
+exports.PostHogSurveys = __webpack_exports__.PostHogSurveys;
+exports.SurveyEventName = __webpack_exports__.SurveyEventName;
+exports.SurveyEventProperties = __webpack_exports__.SurveyEventProperties;
+exports.SurveyEventType = __webpack_exports__.SurveyEventType;
+exports.SurveyPosition = __webpack_exports__.SurveyPosition;
+exports.SurveyQuestionBranchingType = __webpack_exports__.SurveyQuestionBranchingType;
+exports.SurveyQuestionType = __webpack_exports__.SurveyQuestionType;
+exports.SurveySchedule = __webpack_exports__.SurveySchedule;
+exports.SurveyTabPosition = __webpack_exports__.SurveyTabPosition;
+exports.SurveyType = __webpack_exports__.SurveyType;
+exports.SurveyWidgetType = __webpack_exports__.SurveyWidgetType;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DisplaySurveyType",
+    "PostHogSurveys",
+    "SurveyEventName",
+    "SurveyEventProperties",
+    "SurveyEventType",
+    "SurveyPosition",
+    "SurveyQuestionBranchingType",
+    "SurveyQuestionType",
+    "SurveySchedule",
+    "SurveyTabPosition",
+    "SurveyType",
+    "SurveyWidgetType"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});