@posthog/browser-common 0.9.5 → 0.9.7

package/dist/client.d.ts

@@ -31,6 +31,8 @@ export interface CapturedEventInfo {
 }
 /** Per-call capture overrides, mirroring the client's public capture options. */
 export interface CaptureOptions {
+    /** Send immediately without batching, using best-effort unload-safe delivery. */
+    delivery?: 'unload';
     /** Override the event timestamp sent to PostHog. UTC is preferred; non-UTC input is converted to UTC. */
     timestamp?: Date;
     /** Override the event UUID used for de-duplication. */
@@ -102,6 +104,8 @@ export interface Client {
     readonly groups: DeepReadonly<Record<string, string>>;
     /** The current session, if one exists. Reading it need not create one. */
     readonly session: SessionContext | undefined;
+    /** Effective consent opt-out state. Cookieless capture may still be permitted while opted out. */
+    readonly isOptedOut: boolean;
     /** Whether the host currently permits data capture. */
     readonly canCapture: boolean;
     /** Synchronously admits an analytics event to the client's normal pipeline. */
@@ -112,6 +116,8 @@ export interface Client {
     getExtension<T extends Extension>(token: ExtensionToken<T>): T | undefined;
     /** Returns the extension registered under a stable name, or `undefined` when it is not installed. */
     getExtension<T extends Extension = Extension>(name: string): T | undefined;
+    /** Observes session IDs through the host's session notifications, without creating a session. May replay an existing session on subscription. */
+    readonly onSession: Listener<string>;
     /** Fires for every captured event through a deeply readonly view. */
     readonly onEvent: Listener<CapturedEventInfo>;
     /** Replays the latest available remote-config outcome and fires subsequent outcomes when the host makes them available. */

package/dist/config.js

@@ -27,7 +27,7 @@ var __webpack_require__ = {};
 })();
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
-const packageVersion = "0.9.5";
+const packageVersion = "0.9.7";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/config.mjs

@@ -1,4 +1,4 @@
-const packageVersion = "0.9.5";
+const packageVersion = "0.9.7";
 const Config = {
     DEBUG: false,
     LIB_VERSION: packageVersion,

package/dist/feature-flags.d.ts

@@ -75,6 +75,7 @@ export declare class PostHogFeatureFlags implements Extension {
     private _reloadingDisabled;
     private _additionalReloadRequested;
     private _reloadDebouncer;
+    private _firingFeatureFlagsCallbacks;
     private _flagsLoadedFromRemote;
     private _staleCacheRefreshTriggered;
     private _consecutiveStatusZeroFailures;

package/dist/feature-flags.js

@@ -206,6 +206,7 @@ class PostHogFeatureFlags {
         this._requestGeneration = 0;
         this._reloadingDisabled = false;
         this._additionalReloadRequested = false;
+        this._firingFeatureFlagsCallbacks = false;
         this._flagsLoadedFromRemote = false;
         this._staleCacheRefreshTriggered = false;
         this._consecutiveStatusZeroFailures = 0;
@@ -598,6 +599,7 @@ class PostHogFeatureFlags {
     reloadFeatureFlags() {
         if (this._reloadingDisabled || this._config.featureFlagsDisabled) return;
         if (this._hasStatusZeroCircuitBreakerTripped()) return;
+        if (this._firingFeatureFlagsCallbacks) this._logger.warn("reloadFeatureFlags() was called inside an onFeatureFlags callback. This callback also runs when flags change in other tabs, so this can cause a request loop.");
         if (this._requestInFlight) this._additionalReloadRequested = true;
         if (this._reloadDebouncer) return;
         this._reloadingHandlers.slice().forEach((handler)=>{
@@ -1114,6 +1116,8 @@ class PostHogFeatureFlags {
     _fireFeatureFlagsCallbacks(errorsLoading) {
         this._rebuildEventProperties();
         const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks();
+        const wasFiring = this._firingFeatureFlagsCallbacks;
+        this._firingFeatureFlagsCallbacks = true;
         this.featureFlagEventHandlers.forEach((handler)=>{
             try {
                 handler(flags, flagVariants, {
@@ -1123,6 +1127,7 @@ class PostHogFeatureFlags {
                 this._logger.error('Error while running feature flags callback', error);
             }
         });
+        this._firingFeatureFlagsCallbacks = wasFiring;
     }
     setPersonPropertiesForFlags(properties, reloadFeatureFlags = true) {
         this._setPersonPropertiesForFlags(properties, reloadFeatureFlags);

package/dist/feature-flags.mjs

@@ -170,6 +170,7 @@ class PostHogFeatureFlags {
         this._requestGeneration = 0;
         this._reloadingDisabled = false;
         this._additionalReloadRequested = false;
+        this._firingFeatureFlagsCallbacks = false;
         this._flagsLoadedFromRemote = false;
         this._staleCacheRefreshTriggered = false;
         this._consecutiveStatusZeroFailures = 0;
@@ -562,6 +563,7 @@ class PostHogFeatureFlags {
     reloadFeatureFlags() {
         if (this._reloadingDisabled || this._config.featureFlagsDisabled) return;
         if (this._hasStatusZeroCircuitBreakerTripped()) return;
+        if (this._firingFeatureFlagsCallbacks) this._logger.warn("reloadFeatureFlags() was called inside an onFeatureFlags callback. This callback also runs when flags change in other tabs, so this can cause a request loop.");
         if (this._requestInFlight) this._additionalReloadRequested = true;
         if (this._reloadDebouncer) return;
         this._reloadingHandlers.slice().forEach((handler)=>{
@@ -1078,6 +1080,8 @@ class PostHogFeatureFlags {
     _fireFeatureFlagsCallbacks(errorsLoading) {
         this._rebuildEventProperties();
         const { flags, flagVariants } = this._prepareFeatureFlagsForCallbacks();
+        const wasFiring = this._firingFeatureFlagsCallbacks;
+        this._firingFeatureFlagsCallbacks = true;
         this.featureFlagEventHandlers.forEach((handler)=>{
             try {
                 handler(flags, flagVariants, {
@@ -1087,6 +1091,7 @@ class PostHogFeatureFlags {
                 this._logger.error('Error while running feature flags callback', error);
             }
         });
+        this._firingFeatureFlagsCallbacks = wasFiring;
     }
     setPersonPropertiesForFlags(properties, reloadFeatureFlags = true) {
         this._setPersonPropertiesForFlags(properties, reloadFeatureFlags);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export { SurveyEventType, SurveyWidgetType, SurveyPosition, SurveyTabPosition, SurveyType, SurveyQuestionType, SurveyQuestionBranchingType, SurveySchedule, SurveyEventName, SurveyEventProperties, DisplaySurveyType, } from './survey-constants';
 /**
  * Public surface for browser extensions shared across PostHog JavaScript SDK
  * clients.

package/dist/index.js

@@ -9,6 +9,9 @@ var __webpack_modules__ = {
     "./pubsub" (module) {
         module.exports = require("./pubsub.js");
     },
+    "./survey-constants" (module) {
+        module.exports = require("./survey-constants.js");
+    },
     "./types" (module) {
         module.exports = require("./types/index.js");
     }
@@ -60,30 +63,75 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _extension_tokens__rspack_import_0 = __webpack_require__("./extension-tokens");
-    var _types__rspack_import_1 = __webpack_require__("./types");
+    var _survey_constants__rspack_import_0 = __webpack_require__("./survey-constants");
+    var _extension_tokens__rspack_import_1 = __webpack_require__("./extension-tokens");
+    var _types__rspack_import_2 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_1)if ([
+    for(const __rspack_import_key in _types__rspack_import_2)if ([
+        "SurveyEventProperties",
+        "SurveyWidgetType",
         "Publisher",
+        "SurveyTabPosition",
+        "SurveyEventName",
+        "SurveyQuestionBranchingType",
+        "DisplaySurveyType",
+        "SurveySchedule",
+        "default",
+        "SurveyType",
+        "SurveyPosition",
         "createDisposable",
         "FeatureFlagsCommonExtension",
-        "default"
-    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_1[__rspack_import_key];
+        "SurveyQuestionType",
+        "SurveyEventType"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_2[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _disposable__rspack_import_2 = __webpack_require__("./disposable");
-    var _pubsub__rspack_import_3 = __webpack_require__("./pubsub");
+    var _disposable__rspack_import_3 = __webpack_require__("./disposable");
+    var _pubsub__rspack_import_4 = __webpack_require__("./pubsub");
     __webpack_require__.d(__webpack_exports__, {
-        FeatureFlagsCommonExtension: ()=>_extension_tokens__rspack_import_0.FeatureFlagsCommonExtension,
-        Publisher: ()=>_pubsub__rspack_import_3.Publisher,
-        createDisposable: ()=>_disposable__rspack_import_2.createDisposable
+        DisplaySurveyType: ()=>_survey_constants__rspack_import_0.DisplaySurveyType,
+        FeatureFlagsCommonExtension: ()=>_extension_tokens__rspack_import_1.FeatureFlagsCommonExtension,
+        Publisher: ()=>_pubsub__rspack_import_4.Publisher,
+        SurveyEventName: ()=>_survey_constants__rspack_import_0.SurveyEventName,
+        SurveyEventProperties: ()=>_survey_constants__rspack_import_0.SurveyEventProperties,
+        SurveyEventType: ()=>_survey_constants__rspack_import_0.SurveyEventType,
+        SurveyPosition: ()=>_survey_constants__rspack_import_0.SurveyPosition,
+        SurveyQuestionBranchingType: ()=>_survey_constants__rspack_import_0.SurveyQuestionBranchingType,
+        SurveyQuestionType: ()=>_survey_constants__rspack_import_0.SurveyQuestionType,
+        SurveySchedule: ()=>_survey_constants__rspack_import_0.SurveySchedule,
+        SurveyTabPosition: ()=>_survey_constants__rspack_import_0.SurveyTabPosition,
+        SurveyType: ()=>_survey_constants__rspack_import_0.SurveyType,
+        SurveyWidgetType: ()=>_survey_constants__rspack_import_0.SurveyWidgetType,
+        createDisposable: ()=>_disposable__rspack_import_3.createDisposable
     });
 })();
+exports.DisplaySurveyType = __webpack_exports__.DisplaySurveyType;
 exports.FeatureFlagsCommonExtension = __webpack_exports__.FeatureFlagsCommonExtension;
 exports.Publisher = __webpack_exports__.Publisher;
+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;
 exports.createDisposable = __webpack_exports__.createDisposable;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DisplaySurveyType",
     "FeatureFlagsCommonExtension",
     "Publisher",
+    "SurveyEventName",
+    "SurveyEventProperties",
+    "SurveyEventType",
+    "SurveyPosition",
+    "SurveyQuestionBranchingType",
+    "SurveyQuestionType",
+    "SurveySchedule",
+    "SurveyTabPosition",
+    "SurveyType",
+    "SurveyWidgetType",
     "createDisposable"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/index.mjs

@@ -1,4 +1,5 @@
 export * from "./types/index.mjs";
+export { DisplaySurveyType, SurveyEventName, SurveyEventProperties, SurveyEventType, SurveyPosition, SurveyQuestionBranchingType, SurveyQuestionType, SurveySchedule, SurveyTabPosition, SurveyType, SurveyWidgetType } from "./survey-constants.mjs";
 export { FeatureFlagsCommonExtension } from "./extension-tokens.mjs";
 export { createDisposable } from "./disposable.mjs";
 export { Publisher } from "./pubsub.mjs";

package/dist/survey-action-matcher.d.ts

@@ -0,0 +1,27 @@
+import type { SurveyActionHost, SurveyCapturedEvent as CaptureResult } from './survey-event-host';
+import type { SurveyActionType } from './types/surveys';
+export declare class ActionMatcher {
+    private readonly _host?;
+    private readonly _actionRegistry;
+    private readonly _actionEvents;
+    private _debugEventEmitter;
+    private _captureHookUnsubscribe;
+    constructor(_host?: SurveyActionHost | undefined);
+    init(): void;
+    dispose(): void;
+    register(actions: SurveyActionType[]): void;
+    replace(actions: SurveyActionType[]): void;
+    on(eventName: string, eventPayload?: CaptureResult): void;
+    _addActionHook(callback: (actionName: string, eventPayload?: any) => void): void;
+    private _checkAction;
+    onAction(event: 'actionCaptured', cb: (...args: any[]) => void): () => void;
+    private _checkStep;
+    private _checkStepEvent;
+    private _checkStepUrl;
+    private _checkStepElement;
+    private _checkStepHref;
+    private _checkStepText;
+    private _checkStepSelector;
+    private _getElementsList;
+    private _checkStepProperties;
+}

package/dist/survey-action-matcher.js

@@ -0,0 +1,169 @@
+"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__, {
+    ActionMatcher: ()=>ActionMatcher
+});
+const simple_event_emitter_js_namespaceObject = require("./utils/simple-event-emitter.js");
+const core_namespaceObject = require("@posthog/core");
+const surveys_namespaceObject = require("@posthog/core/surveys");
+const elements_chain_utils_js_namespaceObject = require("./utils/elements-chain-utils.js");
+class ActionMatcher {
+    constructor(_host){
+        this._host = _host;
+        this._actionRegistry = new Set();
+        this._actionEvents = new Set();
+        this._debugEventEmitter = new simple_event_emitter_js_namespaceObject.SimpleEventEmitter();
+        this._checkStep = (event, step)=>this._checkStepEvent(event, step) && this._checkStepUrl(event, step) && this._checkStepElement(event, step) && this._checkStepProperties(event, step);
+        this._checkStepEvent = (event, step)=>{
+            if (step?.event && event?.event !== step?.event) return false;
+            return true;
+        };
+    }
+    init() {
+        if (!(0, core_namespaceObject.isUndefined)(this._host?.subscribeCapture)) {
+            const matchEventToAction = (eventName, eventPayload)=>{
+                this.on(eventName, eventPayload);
+            };
+            this._captureHookUnsubscribe = this._host?.subscribeCapture(matchEventToAction);
+        }
+    }
+    dispose() {
+        this._captureHookUnsubscribe?.();
+        this._captureHookUnsubscribe = void 0;
+        this._host?.setElementSelectors?.(new Set(), this);
+        this._debugEventEmitter = new simple_event_emitter_js_namespaceObject.SimpleEventEmitter();
+    }
+    register(actions) {
+        if ((0, core_namespaceObject.isUndefined)(this._host?.subscribeCapture)) return;
+        actions.forEach((action)=>{
+            this._actionRegistry.add(action);
+            action.steps?.forEach((step)=>{
+                this._actionEvents.add(step?.event || '');
+            });
+        });
+        if (this._host?.setElementSelectors) {
+            const selectorsToWatch = new Set();
+            this._actionRegistry.forEach((action)=>{
+                action.steps?.forEach((step)=>{
+                    if (step?.selector) selectorsToWatch.add(step.selector);
+                });
+            });
+            this._host.setElementSelectors(selectorsToWatch, this);
+        }
+    }
+    replace(actions) {
+        this._actionRegistry.clear();
+        this._actionEvents.clear();
+        this.register(actions);
+    }
+    on(eventName, eventPayload) {
+        if (null == eventPayload || 0 == eventName.length) return;
+        if (!this._actionEvents.has(eventName) && !this._actionEvents.has(eventPayload.event)) return;
+        this._actionRegistry.forEach((action)=>{
+            if (this._checkAction(eventPayload, action)) this._debugEventEmitter.emit('actionCaptured', action.name);
+        });
+    }
+    _addActionHook(callback) {
+        this.onAction('actionCaptured', (data)=>callback(data));
+    }
+    _checkAction(event, action) {
+        if (action?.steps == null) return false;
+        for (const step of action.steps)if (this._checkStep(event, step)) return true;
+        return false;
+    }
+    onAction(event, cb) {
+        return this._debugEventEmitter.on(event, cb);
+    }
+    _checkStepUrl(event, step) {
+        if (step?.url) {
+            const eventUrl = event?.properties?.$current_url;
+            if (!eventUrl || 'string' != typeof eventUrl) return false;
+            if (!(0, elements_chain_utils_js_namespaceObject.matchString)(eventUrl, step.url, step.url_matching || 'contains')) return false;
+        }
+        return true;
+    }
+    _checkStepElement(event, step) {
+        if (!this._checkStepHref(event, step)) return false;
+        if (!this._checkStepText(event, step)) return false;
+        if (!this._checkStepSelector(event, step)) return false;
+        return true;
+    }
+    _checkStepHref(event, step) {
+        if (!step?.href) return true;
+        const elements = this._getElementsList(event);
+        if (elements.length > 0) return elements.some((el)=>(0, elements_chain_utils_js_namespaceObject.matchString)(el.href, step.href, step.href_matching || 'exact'));
+        const chain = event?.properties?.$elements_chain || '';
+        if (chain) return (0, elements_chain_utils_js_namespaceObject.matchString)((0, elements_chain_utils_js_namespaceObject.extractHref)(chain), step.href, step.href_matching || 'exact');
+        return false;
+    }
+    _checkStepText(event, step) {
+        if (!step?.text) return true;
+        const elements = this._getElementsList(event);
+        if (elements.length > 0) return elements.some((el)=>(0, elements_chain_utils_js_namespaceObject.matchString)(el.text, step.text, step.text_matching || 'exact') || (0, elements_chain_utils_js_namespaceObject.matchString)(el.$el_text, step.text, step.text_matching || 'exact'));
+        const chain = event?.properties?.$elements_chain || '';
+        if (chain) return (0, elements_chain_utils_js_namespaceObject.matchTexts)((0, elements_chain_utils_js_namespaceObject.extractTexts)(chain), step.text, step.text_matching || 'exact');
+        return false;
+    }
+    _checkStepSelector(event, step) {
+        if (!step?.selector) return true;
+        const elementSelectors = event?.properties?.$element_selectors;
+        if (elementSelectors?.includes(step.selector)) return true;
+        const chain = event?.properties?.$elements_chain || '';
+        if (step.selector_regex && chain) try {
+            return new RegExp(step.selector_regex).test(chain);
+        } catch  {}
+        return false;
+    }
+    _getElementsList(event) {
+        if (event?.properties?.$elements == null) return [];
+        return event?.properties.$elements;
+    }
+    _checkStepProperties(event, step) {
+        if (!step?.properties || 0 === step.properties.length) return true;
+        const propertyFilters = step.properties.reduce((acc, filter)=>{
+            const values = (0, core_namespaceObject.isArray)(filter.value) ? filter.value.map(String) : null != filter.value ? [
+                String(filter.value)
+            ] : [];
+            acc[filter.key] = {
+                values,
+                operator: filter.operator || 'exact'
+            };
+            return acc;
+        }, {});
+        return (0, surveys_namespaceObject.matchPropertyFilters)(propertyFilters, event?.properties);
+    }
+}
+exports.ActionMatcher = __webpack_exports__.ActionMatcher;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ActionMatcher"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/survey-action-matcher.mjs

@@ -0,0 +1,131 @@
+import { SimpleEventEmitter } from "./utils/simple-event-emitter.mjs";
+import { isArray, isUndefined } from "@posthog/core";
+import { matchPropertyFilters } from "@posthog/core/surveys";
+import { extractHref, extractTexts, matchString, matchTexts } from "./utils/elements-chain-utils.mjs";
+class ActionMatcher {
+    constructor(_host){
+        this._host = _host;
+        this._actionRegistry = new Set();
+        this._actionEvents = new Set();
+        this._debugEventEmitter = new SimpleEventEmitter();
+        this._checkStep = (event, step)=>this._checkStepEvent(event, step) && this._checkStepUrl(event, step) && this._checkStepElement(event, step) && this._checkStepProperties(event, step);
+        this._checkStepEvent = (event, step)=>{
+            if (step?.event && event?.event !== step?.event) return false;
+            return true;
+        };
+    }
+    init() {
+        if (!isUndefined(this._host?.subscribeCapture)) {
+            const matchEventToAction = (eventName, eventPayload)=>{
+                this.on(eventName, eventPayload);
+            };
+            this._captureHookUnsubscribe = this._host?.subscribeCapture(matchEventToAction);
+        }
+    }
+    dispose() {
+        this._captureHookUnsubscribe?.();
+        this._captureHookUnsubscribe = void 0;
+        this._host?.setElementSelectors?.(new Set(), this);
+        this._debugEventEmitter = new SimpleEventEmitter();
+    }
+    register(actions) {
+        if (isUndefined(this._host?.subscribeCapture)) return;
+        actions.forEach((action)=>{
+            this._actionRegistry.add(action);
+            action.steps?.forEach((step)=>{
+                this._actionEvents.add(step?.event || '');
+            });
+        });
+        if (this._host?.setElementSelectors) {
+            const selectorsToWatch = new Set();
+            this._actionRegistry.forEach((action)=>{
+                action.steps?.forEach((step)=>{
+                    if (step?.selector) selectorsToWatch.add(step.selector);
+                });
+            });
+            this._host.setElementSelectors(selectorsToWatch, this);
+        }
+    }
+    replace(actions) {
+        this._actionRegistry.clear();
+        this._actionEvents.clear();
+        this.register(actions);
+    }
+    on(eventName, eventPayload) {
+        if (null == eventPayload || 0 == eventName.length) return;
+        if (!this._actionEvents.has(eventName) && !this._actionEvents.has(eventPayload.event)) return;
+        this._actionRegistry.forEach((action)=>{
+            if (this._checkAction(eventPayload, action)) this._debugEventEmitter.emit('actionCaptured', action.name);
+        });
+    }
+    _addActionHook(callback) {
+        this.onAction('actionCaptured', (data)=>callback(data));
+    }
+    _checkAction(event, action) {
+        if (action?.steps == null) return false;
+        for (const step of action.steps)if (this._checkStep(event, step)) return true;
+        return false;
+    }
+    onAction(event, cb) {
+        return this._debugEventEmitter.on(event, cb);
+    }
+    _checkStepUrl(event, step) {
+        if (step?.url) {
+            const eventUrl = event?.properties?.$current_url;
+            if (!eventUrl || 'string' != typeof eventUrl) return false;
+            if (!matchString(eventUrl, step.url, step.url_matching || 'contains')) return false;
+        }
+        return true;
+    }
+    _checkStepElement(event, step) {
+        if (!this._checkStepHref(event, step)) return false;
+        if (!this._checkStepText(event, step)) return false;
+        if (!this._checkStepSelector(event, step)) return false;
+        return true;
+    }
+    _checkStepHref(event, step) {
+        if (!step?.href) return true;
+        const elements = this._getElementsList(event);
+        if (elements.length > 0) return elements.some((el)=>matchString(el.href, step.href, step.href_matching || 'exact'));
+        const chain = event?.properties?.$elements_chain || '';
+        if (chain) return matchString(extractHref(chain), step.href, step.href_matching || 'exact');
+        return false;
+    }
+    _checkStepText(event, step) {
+        if (!step?.text) return true;
+        const elements = this._getElementsList(event);
+        if (elements.length > 0) return elements.some((el)=>matchString(el.text, step.text, step.text_matching || 'exact') || matchString(el.$el_text, step.text, step.text_matching || 'exact'));
+        const chain = event?.properties?.$elements_chain || '';
+        if (chain) return matchTexts(extractTexts(chain), step.text, step.text_matching || 'exact');
+        return false;
+    }
+    _checkStepSelector(event, step) {
+        if (!step?.selector) return true;
+        const elementSelectors = event?.properties?.$element_selectors;
+        if (elementSelectors?.includes(step.selector)) return true;
+        const chain = event?.properties?.$elements_chain || '';
+        if (step.selector_regex && chain) try {
+            return new RegExp(step.selector_regex).test(chain);
+        } catch  {}
+        return false;
+    }
+    _getElementsList(event) {
+        if (event?.properties?.$elements == null) return [];
+        return event?.properties.$elements;
+    }
+    _checkStepProperties(event, step) {
+        if (!step?.properties || 0 === step.properties.length) return true;
+        const propertyFilters = step.properties.reduce((acc, filter)=>{
+            const values = isArray(filter.value) ? filter.value.map(String) : null != filter.value ? [
+                String(filter.value)
+            ] : [];
+            acc[filter.key] = {
+                values,
+                operator: filter.operator || 'exact'
+            };
+            return acc;
+        }, {});
+        return matchPropertyFilters(propertyFilters, event?.properties);
+    }
+}
+export { ActionMatcher };

package/dist/survey-constants.d.ts

@@ -0,0 +1,86 @@
+export declare const SurveyEventType: {
+    readonly Activation: 'events';
+    readonly Cancellation: 'cancelEvents';
+};
+export declare const SurveyWidgetType: {
+    readonly Button: 'button';
+    readonly Tab: 'tab';
+    readonly Selector: 'selector';
+};
+export declare const SurveyPosition: {
+    readonly TopLeft: 'top_left';
+    readonly TopRight: 'top_right';
+    readonly TopCenter: 'top_center';
+    readonly MiddleLeft: 'middle_left';
+    readonly MiddleRight: 'middle_right';
+    readonly MiddleCenter: 'middle_center';
+    readonly Left: 'left';
+    readonly Center: 'center';
+    readonly Right: 'right';
+    readonly NextToTrigger: 'next_to_trigger';
+};
+export declare const SurveyTabPosition: {
+    readonly Top: 'top';
+    readonly Left: 'left';
+    readonly Right: 'right';
+    readonly Bottom: 'bottom';
+};
+export declare const SurveyType: {
+    readonly Popover: 'popover';
+    readonly API: 'api';
+    readonly Widget: 'widget';
+    readonly ExternalSurvey: 'external_survey';
+};
+export declare const SurveyQuestionType: {
+    readonly Open: 'open';
+    readonly MultipleChoice: 'multiple_choice';
+    readonly SingleChoice: 'single_choice';
+    readonly Rating: 'rating';
+    readonly Link: 'link';
+};
+export declare const SurveyQuestionBranchingType: {
+    readonly NextQuestion: 'next_question';
+    readonly End: 'end';
+    readonly ResponseBased: 'response_based';
+    readonly SpecificQuestion: 'specific_question';
+};
+export declare const SurveySchedule: {
+    readonly Once: 'once';
+    readonly Recurring: 'recurring';
+    readonly Always: 'always';
+};
+export declare const SurveyEventName: {
+    readonly SHOWN: 'survey shown';
+    readonly DISMISSED: 'survey dismissed';
+    readonly SENT: 'survey sent';
+    readonly ABANDONED: 'survey abandoned';
+};
+export declare const SurveyEventProperties: {
+    readonly SURVEY_ID: '$survey_id';
+    readonly SURVEY_NAME: '$survey_name';
+    readonly SURVEY_RESPONSE: '$survey_response';
+    readonly SURVEY_ITERATION: '$survey_iteration';
+    readonly SURVEY_ITERATION_START_DATE: '$survey_iteration_start_date';
+    readonly SURVEY_PARTIALLY_COMPLETED: '$survey_partially_completed';
+    readonly SURVEY_SUBMISSION_ID: '$survey_submission_id';
+    readonly SURVEY_QUESTIONS: '$survey_questions';
+    readonly SURVEY_COMPLETED: '$survey_completed';
+    readonly PRODUCT_TOUR_ID: '$product_tour_id';
+    readonly SURVEY_LAST_SEEN_DATE: '$survey_last_seen_date';
+    readonly SURVEY_LANGUAGE: '$survey_language';
+};
+export declare const DisplaySurveyType: {
+    readonly Popover: 'popover';
+    readonly Inline: 'inline';
+};
+export type SurveyEventType = (typeof SurveyEventType)[keyof typeof SurveyEventType];
+export type SurveyWidgetType = (typeof SurveyWidgetType)[keyof typeof SurveyWidgetType];
+export type SurveyPosition = (typeof SurveyPosition)[keyof typeof SurveyPosition];
+export type SurveyTabPosition = (typeof SurveyTabPosition)[keyof typeof SurveyTabPosition];
+export type SurveyType = (typeof SurveyType)[keyof typeof SurveyType];
+export type SurveyQuestionType = (typeof SurveyQuestionType)[keyof typeof SurveyQuestionType];
+export type SurveyQuestionBranchingType = (typeof SurveyQuestionBranchingType)[keyof typeof SurveyQuestionBranchingType];
+export type SurveySchedule = (typeof SurveySchedule)[keyof typeof SurveySchedule];
+export type SurveyEventName = (typeof SurveyEventName)[keyof typeof SurveyEventName];
+export type SurveyEventProperties = (typeof SurveyEventProperties)[keyof typeof SurveyEventProperties];
+export type DisplaySurveyType = (typeof DisplaySurveyType)[keyof typeof DisplaySurveyType];