@snowplow/signals-browser-plugin 0.0.1

package/dist/index.module.js

@@ -0,0 +1,649 @@
+/*!
+ * Snowplow Signals Interventions SDK v0.0.1 (https://github.com/snowplow-incubator/signals-browser-plugin)
+ * Copyright 2025 Snowplow Analytics Ltd
+ * Licensed under BSD-3-Clause
+ */
+
+import { __spreadArray } from 'tslib';
+import { buildSelfDescribingEvent, resolveDynamicContext } from '@snowplow/tracker-core';
+
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["ERROR"] = "error";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+})(LogLevel || (LogLevel = {}));
+var name;
+var LOG;
+/**
+ * Wrap the passed logger so that it's clear which plugin/tracker instance log messages refer to
+ * @param level Log level for the logged message
+ * @param trackerId Tracker ID logging the event
+ * @param args Log message and other arguments
+ */
+var logger = function (level, trackerId) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        args[_i - 2] = arguments[_i];
+    }
+    if (!name || !LOG) {
+        return;
+    }
+    var prefix = "[".concat(name, ":").concat(trackerId, "] ");
+    if (typeof args[0] === 'string') {
+        var msg = prefix + args.shift();
+        LOG[level].apply(LOG, __spreadArray([msg], args, false));
+    }
+    else {
+        LOG[level].apply(LOG, __spreadArray([prefix], args, false));
+    }
+};
+var setLogger = function (plugin, log) {
+    name = plugin;
+    LOG = log;
+};
+
+var ENTITY_ALIASES = ['co', 'cx', 'context', 'entity', 'entities'];
+var EVENT_ALIASES = ['ue', 'ue_pr', 'ue_px', 'unstruct', 'unstruct_event', 'self_describing', 'sde'];
+var EVENT_SCHEMAS = {
+    se: 'iglu:com.google.analytics/event/jsonschema/1-0-0',
+    ev: 'iglu:com.google.analytics/event/jsonschema/1-0-0',
+    ad: 'iglu:com.snowplowanalytics.snowplow/ad_impression/jsonschema/1-0-0',
+    tr: 'iglu:com.snowplowanalytics.snowplow/transaction/jsonschema/1-0-0',
+    ti: 'iglu:com.snowplowanalytics.snowplow/transaction_item/1-0-0',
+    pv: 'iglu:com.snowplowanalytics.snowplow/page_view/jsonschema/1-0-0',
+    pp: 'iglu:com.snowplowanalytics.snowplow/page_ping/jsonschema/1-0-0',
+    ue: '', // here to pass an `in` check below; needs to be extracted from SDJ payload
+};
+var objWithKey = function (obj, key) {
+    return typeof obj === 'object' && obj != null && key in obj;
+};
+var extractUrlFrom = function (part, field) {
+    return function (event) {
+        try {
+            return new URL(event[field])[part].toString() || undefined;
+        }
+        catch (_) {
+            return;
+        }
+    };
+};
+var extractUrlParamFrom = function (param, field) {
+    return function (event) {
+        var _a;
+        try {
+            return (_a = new URL(event[field]).searchParams.get(param)) !== null && _a !== void 0 ? _a : undefined;
+        }
+        catch (_) {
+            return;
+        }
+    };
+};
+var extractParamPartFrom = function (param, field, index, sep) {
+    if (sep === void 0) { sep = '.'; }
+    return function (event) {
+        var _a;
+        try {
+            var full = (_a = new URL(event[field]).searchParams.get(param)) !== null && _a !== void 0 ? _a : undefined;
+            return full ? full.split(sep)[index] : undefined;
+        }
+        catch (_) {
+            return;
+        }
+    };
+};
+var extractDimensionValueFrom = function (dim, field) {
+    return function (event) {
+        try {
+            return event[field].split('x')[dim];
+        }
+        catch (_) {
+            return;
+        }
+    };
+};
+/**
+ * `Payload` instances access data via their tracker protocol field names, rather than the more human-friendly ones users are familiar with from enriched data.
+ * This maps the enriched fields back to their TP equivalents; allowing for field extraction where necessary.
+ */
+var selectorMap = {
+    app_id: 'aid',
+    platform: 'p',
+    dvce_created_tstamp: 'dtm',
+    event: function (_a) {
+        var _b;
+        var e = _a.e;
+        return ((_b = {
+            se: 'struct',
+            ev: 'struct',
+            ue: 'unstruct',
+            ad: 'ad_impression',
+            tr: 'transaction',
+            ti: 'transaction_item',
+            pv: 'page_view',
+            pp: 'page_ping',
+        }[e]) !== null && _b !== void 0 ? _b : e);
+    },
+    event_id: 'eid',
+    txn_id: 'tid',
+    name_tracker: 'tna',
+    v_tracker: 'tv',
+    user_id: 'uid',
+    user_ipaddress: 'ip',
+    user_fingerprint: 'fp',
+    domain_userid: 'duid',
+    domain_sessionidx: 'vid',
+    network_userid: 'nuid',
+    page_url: 'url',
+    page_title: 'page',
+    page_referrer: 'refr',
+    page_urlscheme: extractUrlFrom('protocol', 'url'),
+    page_urlhost: extractUrlFrom('hostname', 'url'),
+    page_urlport: extractUrlFrom('port', 'url'),
+    page_urlpath: extractUrlFrom('pathname', 'url'),
+    page_urlquery: extractUrlFrom('search', 'url'),
+    page_urlfragment: extractUrlFrom('hash', 'url'),
+    refr_urlscheme: extractUrlFrom('protocol', 'refr'),
+    refr_urlhost: extractUrlFrom('hostname', 'refr'),
+    refr_urlport: extractUrlFrom('port', 'refr'),
+    refr_urlpath: extractUrlFrom('pathname', 'refr'),
+    refr_urlquery: extractUrlFrom('search', 'refr'),
+    refr_urlfragment: extractUrlFrom('hash', 'refr'),
+    mkt_medium: extractUrlParamFrom('utm_medium', 'url'),
+    mkt_source: extractUrlParamFrom('utm_source', 'url'),
+    mkt_term: extractUrlParamFrom('utm_term', 'url'),
+    mkt_content: extractUrlParamFrom('utm_content', 'url'),
+    mkt_campaign: extractUrlParamFrom('utm_campaign', 'url'),
+    se_category: 'se_ca',
+    se_action: 'se_ac',
+    se_label: 'se_la',
+    se_property: 'se_pr',
+    se_value: 'se_va',
+    tr_orderid: 'tr_id',
+    tr_affiliation: 'tr_af',
+    tr_total: 'tr_tt',
+    tr_tax: 'tr_tx',
+    tr_shipping: 'tr_sh',
+    tr_city: 'tr_ci',
+    tr_state: 'tr_st',
+    tr_country: 'tr_co',
+    ti_orderid: 'ti_id',
+    ti_sku: 'ti_sk',
+    ti_name: 'ti_na',
+    ti_category: 'ti_ca',
+    ti_price: 'ti_pr',
+    ti_quantity: 'ti_qu',
+    pp_xoffset_min: 'pp_mix',
+    pp_xoffset_max: 'pp_max',
+    pp_yoffset_min: 'pp_miy',
+    pp_yoffset_max: 'pp_may',
+    useragent: function (_a) {
+        var ua = _a.ua;
+        return ua !== null && ua !== void 0 ? ua : navigator.userAgent;
+    }, // often elided and extracted from HTTP header
+    br_lang: 'lang',
+    br_features_pdf: 'f_pdf',
+    br_features_flash: 'f_fla',
+    br_features_java: 'f_java',
+    br_features_director: 'f_dir',
+    br_features_quicktime: 'f_qt',
+    br_features_realplayer: 'f_realp',
+    br_features_windowsmedia: 'f_wma',
+    br_features_gears: 'f_gears',
+    br_features_silverlight: 'f_ag',
+    br_cookies: 'cookie',
+    br_colordepth: 'cd',
+    br_viewwidth: extractDimensionValueFrom(0, 'vp'),
+    br_viewheight: extractDimensionValueFrom(1, 'vp'),
+    os_timezone: 'tz',
+    dvce_screenwidth: extractDimensionValueFrom(0, 'res'),
+    dvce_screenheight: extractDimensionValueFrom(1, 'res'),
+    doc_charset: 'cs',
+    doc_width: extractDimensionValueFrom(0, 'ds'),
+    doc_height: extractDimensionValueFrom(1, 'ds'),
+    tr_currency: 'tr_cu',
+    ti_currency: 'ti_cu',
+    mkt_clickid: extractUrlParamFrom('gclid', 'url'),
+    dvce_sent_tstamp: 'stm',
+    refr_domain_userid: extractParamPartFrom('_sp', 'url', 0),
+    refr_device_tstamp: extractParamPartFrom('_sp', 'url', 1),
+    domain_sessionid: 'sid',
+    event_vendor: function (evt) { var _a; return (_a = getEventSelf(evt)) === null || _a === void 0 ? void 0 : _a.vendor; },
+    event_name: function (evt) { var _a; return (_a = getEventSelf(evt)) === null || _a === void 0 ? void 0 : _a.name; },
+    event_format: function (evt) { var _a; return (_a = getEventSelf(evt)) === null || _a === void 0 ? void 0 : _a.format; },
+    event_version: function (evt) { var _a; return (_a = getEventSelf(evt)) === null || _a === void 0 ? void 0 : _a.version; },
+    true_tstamp: 'ttm',
+};
+var parseJsonPointer = function (pointer) {
+    if (!pointer) {
+        return;
+    }
+    if (pointer[0] !== '/') {
+        pointer = "/".concat(pointer); // for atomic-level fields, this will allow regular names since JSON Pointer isn't super intuitive
+    }
+    return pointer
+        .split('/')
+        .map(function (segment) { return segment.replace(/~1/g, '/').replace(/~0/g, '~'); })
+        .slice(1);
+};
+var parseEncodedFields = function (evt, fields) {
+    return fields.map(function (field) {
+        if (objWithKey(evt, field)) {
+            var val = evt[field];
+            if (typeof val === 'string') {
+                try {
+                    return JSON.parse(val);
+                }
+                catch (_) {
+                    try {
+                        return JSON.parse(atob(val.replace(/[_-]/g, function (m) { return (m == '-' ? '+' : '/'); })));
+                    }
+                    catch (_) { }
+                }
+            }
+        }
+    });
+};
+/**
+ * Build a lookup map of `vendor: name[]` for entities to lookup more easily
+ */
+var summarizeEntities = function (evt) {
+    var fields = parseEncodedFields(evt, ['co', 'cx']);
+    return fields.reduce(function (acc, ctx) {
+        if (objWithKey(ctx, 'data') && Array.isArray(ctx.data)) {
+            ctx.data.forEach(function (entity) {
+                var _a, _b;
+                if (objWithKey(entity, 'schema') && objWithKey(entity, 'data')) {
+                    if (typeof entity.schema === 'string' && entity.schema.indexOf('iglu:') === 0) {
+                        var parts = entity.schema.slice(5).split('/');
+                        if (parts.length !== 4) {
+                            return;
+                        }
+                        var vendor = (acc[parts[0]] = (_a = acc[parts[0]]) !== null && _a !== void 0 ? _a : {});
+                        vendor[parts[1]] = (_b = vendor[parts[1]]) !== null && _b !== void 0 ? _b : [];
+                        vendor[parts[1]].push(entity.data);
+                    }
+                }
+            });
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Build a lookup map of `vendor: name` for SDE payloads to lookup more easily
+ */
+var summarizeEvent = function (evt) {
+    var fields = parseEncodedFields(evt, ['ue_pr', 'ue_px']);
+    return fields.reduce(function (acc, ctx) {
+        var _a;
+        if (objWithKey(ctx, 'data')) {
+            if (objWithKey(ctx.data, 'schema') && objWithKey(ctx.data, 'data')) {
+                var event_1 = ctx.data;
+                if (typeof event_1.schema === 'string' && event_1.schema.indexOf('iglu:') === 0) {
+                    var parts = event_1.schema.slice(5).split('/');
+                    if (parts.length !== 4) {
+                        return;
+                    }
+                    var vendor = (acc[parts[0]] = (_a = acc[parts[0]]) !== null && _a !== void 0 ? _a : {});
+                    vendor[parts[1]] = event_1.data;
+                }
+            }
+        }
+        return acc;
+    }, {});
+};
+var getEventSelf = function (evt) {
+    var _a;
+    var schema = undefined;
+    if (!objWithKey(evt, 'e') || typeof evt.e !== 'string' || !(evt.e in EVENT_SCHEMAS)) {
+        return;
+    }
+    if (evt.e === 'ue') {
+        var fields = parseEncodedFields(evt, ['ue_pr', 'ue_px']);
+        var ue = (_a = fields[0]) !== null && _a !== void 0 ? _a : fields[1];
+        if (objWithKey(ue, 'data') && objWithKey(ue.data, 'schema') && typeof ue.data.schema === 'string') {
+            schema = ue.data.schema;
+        }
+    }
+    else {
+        schema = EVENT_SCHEMAS[evt.e];
+    }
+    if (typeof schema === 'string' && schema.indexOf('iglu:') === 0) {
+        var _b = schema.slice(5).split('/'), vendor = _b[0], name_1 = _b[1], format = _b[2], version = _b[3];
+        return { vendor: vendor, name: name_1, format: format, version: version };
+    }
+};
+var derefJsonPointer = function (pointerString, obj) {
+    var _a, _b;
+    var pointer = parseJsonPointer(pointerString);
+    if (pointer == null) {
+        return obj; // return whole document
+    }
+    if (typeof obj !== 'object' || obj === null) {
+        return; // no segments will work
+    }
+    // map enriched fieldname <> TP field
+    if (pointer[0] in selectorMap) {
+        var mappedSelector = selectorMap[pointer[0]];
+        if (typeof mappedSelector === 'string' && objWithKey(obj, mappedSelector)) {
+            return obj[mappedSelector];
+        }
+        else if (typeof mappedSelector === 'function') {
+            return mappedSelector(obj);
+        }
+    }
+    // descend into nested SDJ payloads
+    var cursor = obj;
+    if (ENTITY_ALIASES.indexOf(pointer[0]) !== -1) {
+        cursor = (_a = {}, _a[pointer[0]] = summarizeEntities(cursor), _a);
+    }
+    if (EVENT_ALIASES.indexOf(pointer[0]) !== -1) {
+        cursor = (_b = {}, _b[pointer[0]] = summarizeEvent(cursor), _b);
+    }
+    for (var _i = 0, pointer_1 = pointer; _i < pointer_1.length; _i++) {
+        var segment = pointer_1[_i];
+        if (objWithKey(cursor, segment)) {
+            cursor = cursor[segment];
+        }
+        else if (Array.isArray(cursor) && cursor.length === 1 && objWithKey(cursor[0], segment)) {
+            cursor = cursor[0][segment];
+        }
+        else
+            return;
+    }
+    return cursor;
+};
+/**
+ * Given a list of rules to extract entity IDs and a Snowplow event payload, return any extracted ID results.
+ * @param targets Map of entity names to rule definitions for how to find ID values
+ * @param pb Snowplow event
+ * @returns Resulting IDs extracted from the event
+ */
+function extractEntityValues(targets, pb) {
+    var extracted = {};
+    Object.entries(targets).forEach(function (_a) {
+        var entityName = _a[0], pointers = _a[1];
+        pointers = Array.isArray(pointers) ? pointers : [pointers];
+        for (var _i = 0, pointers_1 = pointers; _i < pointers_1.length; _i++) {
+            var pointer = pointers_1[_i];
+            if (pointer === '') {
+                continue;
+            }
+            var candidateId = derefJsonPointer(pointer, pb);
+            if (candidateId != null) {
+                extracted[entityName] = String(candidateId);
+                return;
+            }
+        }
+    });
+    return extracted;
+}
+
+var DEFAULT_PULL_API_PATH = '/api/v1/interventions';
+var DEFAULT_ENTITY_TARGETS = {
+    domain_userid: '/domain_userid',
+    domain_sessionid: '/domain_sessionid',
+    //pageview_id: '/co/com.snowplowanalytics.snowplow/web_page/id', // not a default entity seed
+    //tab_id: '/co/com.snowplowanalytics.snowplow/browser_context/tabId', // not a default entity seed
+};
+var DEFAULT_CONNECTION_TIMEOUT_MS = 2500;
+/**
+ * Default `Fetcher` implementation; uses SSEs, auto updates based on observed entity IDs defined with JSON Pointers
+ */
+var InterventionFetcher = /** @class */ (function () {
+    function InterventionFetcher(tracker, dispatch) {
+        this.tracker = tracker;
+        this.dispatch = dispatch;
+        this.entityValues = {};
+        this.aborter = new AbortController();
+        this.timeoutMs = DEFAULT_CONNECTION_TIMEOUT_MS;
+        this.newEndpoint = false;
+        this.currentParams = '';
+        this.entitySelectors = DEFAULT_ENTITY_TARGETS;
+        // reasonable defaults even without any events observed
+        var info = tracker.getDomainUserInfo();
+        this.update({
+            duid: info[1] || undefined,
+            sid: info[6] || undefined,
+        });
+    }
+    InterventionFetcher.prototype.configure = function (_a) {
+        var endpoint = _a.endpoint, _b = _a.apiPath, apiPath = _b === void 0 ? DEFAULT_PULL_API_PATH : _b, _c = _a.entityTargets, entityTargets = _c === void 0 ? DEFAULT_ENTITY_TARGETS : _c, _d = _a.entityIds, entityIds = _d === void 0 ? {} : _d, _e = _a.connectionTimeoutMs, connectionTimeoutMs = _e === void 0 ? DEFAULT_CONNECTION_TIMEOUT_MS : _e;
+        this.entitySelectors = Object.assign({}, this.entitySelectors, entityTargets);
+        this.timeoutMs = connectionTimeoutMs;
+        var prevEndpoint = this.endpoint;
+        this.endpoint = "".concat(/\/\//.test(endpoint) ? endpoint : 'https://' + endpoint).concat(apiPath);
+        this.newEndpoint = prevEndpoint != this.endpoint;
+        this.update(undefined, entityIds);
+    };
+    InterventionFetcher.prototype.update = function (payload, explicitEntities) {
+        if (explicitEntities === void 0) { explicitEntities = {}; }
+        if (payload) {
+            Object.assign(this.entityValues, extractEntityValues(this.entitySelectors, payload));
+        }
+        Object.assign(this.entityValues, explicitEntities);
+        var newParams = new URLSearchParams(this.entityValues).toString();
+        if (this.endpoint && (newParams != this.currentParams || this.newEndpoint)) {
+            logger(LogLevel.DEBUG, this.tracker.id, 'Entity IDs updated', this.entityValues);
+            this.currentParams = newParams;
+            this.requestInterventions();
+        }
+    };
+    /**
+     * Set up a new SSE connection and start dispatching any received events
+     */
+    InterventionFetcher.prototype.requestInterventions = function () {
+        var _this = this;
+        this.aborter.abort(); // abort any previous connection
+        var aborter = (this.aborter = new AbortController()); // new controller to reset aborted state
+        if (!this.endpoint) {
+            logger(LogLevel.ERROR, this.tracker.id, 'Requested interventions from undefined endpoint');
+            return;
+        }
+        var url = "".concat(this.endpoint, "?").concat(this.currentParams);
+        var stream = new EventSource(url);
+        aborter.signal.addEventListener('abort', stream.close.bind(stream), {
+            once: true,
+        });
+        var timeout = setTimeout(aborter.abort.bind(aborter), this.timeoutMs);
+        stream.addEventListener('open', function () { return clearTimeout(timeout); }, {
+            once: true,
+        });
+        stream.addEventListener('error', function (ev) {
+            return logger(LogLevel.ERROR, _this.tracker.id, 'Error fetching interventions:', ev);
+        });
+        stream.addEventListener('message', function (ev) {
+            _this.dispatch(JSON.parse(ev.data), _this.tracker);
+        });
+    };
+    /**
+     * Factory to match signature of public interface and create the default fetcher instance
+     * @param tracker Tracker activating the plugin
+     * @param dispatch Callback to pass interventions to
+     * @returns `InterventionFetcher` instance
+     */
+    InterventionFetcher.create = function (tracker, dispatch) { return new InterventionFetcher(tracker, dispatch); };
+    return InterventionFetcher;
+}());
+
+var Events = {
+    INTERVENTION_RECEIVED: 'iglu:com.snowplowanalytics.signals/intervention_receive/jsonschema/1-0-0',
+    INTERVENTION_HANDLE: 'iglu:com.snowplowanalytics.signals/intervention_handle/jsonschema/1-0-0',
+    INTERVENTION_HANDLE_ERROR: 'iglu:com.snowplowanalytics.signals/intervention_handle_error/jsonschema/1-0-0',
+};
+var Entities = {
+    INTERVENTION: 'iglu:com.snowplowanalytics.signals/intervention_instance/jsonschema/1-0-0',
+};
+var MEASUREMENT_EVENTS = {
+    delivery: Events.INTERVENTION_RECEIVED,
+    dispatch_accept: Events.INTERVENTION_HANDLE,
+    dispatch_error: Events.INTERVENTION_HANDLE_ERROR,
+};
+
+var DEFAULT_MEASUREMENT_SETTINGS = {
+    delivery: true,
+    dispatch_accept: true,
+    dispatch_error: true,
+};
+/* Per-tracker state */
+var instances = {}; // entities will likely vary by tracker, so each set will need its own fetcher
+var handlerRegistry = {}; // handlers can be added/removed for individual trackers
+var measurementSettings = {}; // currently global and only specified per-plugin instance but may be required in future
+/**
+ * Create an instance of the Signals Interventions plugin.
+ * @param configuration Configuration for the plugin
+ * @returns Configured plugin instance
+ */
+function SignalsInterventionsPlugin(_a) {
+    var _b = _a === void 0 ? {
+        measurement: DEFAULT_MEASUREMENT_SETTINGS,
+        handlers: {},
+    } : _a, fetcher = _b.fetcher, _c = _b.measurement, measurement = _c === void 0 ? DEFAULT_MEASUREMENT_SETTINGS : _c, _d = _b.handlers, handlers = _d === void 0 ? {} : _d;
+    return {
+        activateBrowserPlugin: function (tracker) {
+            var _a;
+            logger(LogLevel.INFO, tracker.id, 'Activating plugin for tracker');
+            instances[tracker.id] = fetcher ? fetcher(tracker, dispatch) : InterventionFetcher.create(tracker, dispatch);
+            measurementSettings[tracker.id] = Object.assign({}, DEFAULT_MEASUREMENT_SETTINGS, measurement);
+            handlerRegistry[tracker.id] = Object.assign((_a = handlerRegistry[tracker.id]) !== null && _a !== void 0 ? _a : {}, handlers);
+        },
+        afterTrack: function (payload) {
+            var trackerName = payload['tna'];
+            if (typeof trackerName === 'string' && trackerName in instances) {
+                instances[trackerName].update(payload);
+            }
+        },
+        logger: function (LOG) {
+            setLogger(SignalsInterventionsPlugin.name, LOG);
+        },
+    };
+}
+/**
+ * Tracks an event upon receipt/handling of an intervention unless configured not to.
+ * @param settings Measurement settings defining whether an event should fire or not, and configuring custom context
+ * @param tracker The tracker to track the event with
+ * @param measurement The type of event to track
+ * @param intervention The intervention payload in question
+ * @param payload An event-specific payload, if required according to `measurement`
+ */
+var measure = function (settings, tracker, measurement, intervention, payload) {
+    var _a;
+    var filter = settings[measurement];
+    if (filter && (typeof filter !== 'function' || filter(intervention))) {
+        var entities = [
+            {
+                schema: Entities.INTERVENTION,
+                data: {
+                    intervention_id: intervention.intervention_id,
+                    name: intervention.name,
+                    version: intervention.version,
+                    entity: intervention.target_entity,
+                    attributes: intervention.attributes,
+                },
+            },
+        ];
+        tracker.core.track(buildSelfDescribingEvent({
+            event: {
+                schema: MEASUREMENT_EVENTS[measurement],
+                data: payload,
+            },
+        }), resolveDynamicContext(__spreadArray(__spreadArray([], entities, true), ((_a = settings.context) !== null && _a !== void 0 ? _a : []), true), measurement, intervention, payload));
+    }
+};
+/**
+ * Called by the `Fetcher` to track receipt of an Intervention and distribute to any handlers
+ * @param intervention The intervention payload that was fetched
+ * @param tracker The tracker associated with the plugin
+ */
+var dispatch = function (intervention, tracker) {
+    var _a, _b;
+    var measurement = (_a = measurementSettings[tracker.id]) !== null && _a !== void 0 ? _a : DEFAULT_MEASUREMENT_SETTINGS;
+    var handlers = (_b = handlerRegistry[tracker.id]) !== null && _b !== void 0 ? _b : {};
+    var handlerIds = Object.keys(handlers);
+    if (!handlerIds.length) {
+        return logger(LogLevel.WARN, tracker.id, 'No handlers registered for intervention', intervention);
+    }
+    logger(LogLevel.INFO, tracker.id, 'Attempting dispatch for intervention', intervention, handlerIds);
+    measure(measurement, tracker, 'delivery', intervention, {
+        handlers: handlerIds,
+    });
+    for (var _i = 0, _c = Object.entries(handlers); _i < _c.length; _i++) {
+        var _d = _c[_i], handlerId = _d[0], handler = _d[1];
+        setTimeout(function (handlerId, handler, intervention, tracker) {
+            var success = function () {
+                logger(LogLevel.INFO, tracker.id, 'Intervention handled', handlerId, intervention);
+                measure(measurement, tracker, 'dispatch_accept', intervention, {
+                    handler: handlerId,
+                });
+            };
+            var failure = function (err) {
+                logger(LogLevel.ERROR, tracker.id, 'Handler failed processing intervention', err, handlerId, intervention);
+                measure(measurement, tracker, 'dispatch_error', intervention, {
+                    handler: handlerId,
+                    error: err ? String(err) : undefined,
+                });
+            };
+            try {
+                var result = handler(intervention, tracker);
+                if (result instanceof Promise) {
+                    result.then(success, failure);
+                }
+                else if (objWithKey(result, 'then') && typeof result.then === 'function') {
+                    result.then(success, failure);
+                }
+                else
+                    success();
+            }
+            catch (e) {
+                failure(e);
+            }
+        }, 0, handlerId, handler, intervention, tracker);
+    }
+};
+/**
+ * Configure the endpoint information for the plugin's `Fetcher` to subscribe to events from
+ * @param config Configuration about the endpoint and entity IDs/definitions to configure
+ * @param trackers List of tracker IDs that have activated the plugin to configure a `Fetcher` for
+ */
+function subscribeToInterventions(config, trackers) {
+    if (trackers === void 0) { trackers = Object.keys(instances); }
+    for (var _i = 0, trackers_1 = trackers; _i < trackers_1.length; _i++) {
+        var trackerId = trackers_1[_i];
+        if (trackerId in instances) {
+            instances[trackerId].configure(config);
+        }
+    }
+}
+/**
+ * Start calling the given handlers when new interventions are received
+ * @param handlers Map of handler IDs to handler functions to call with new interventions
+ * @param trackers List of tracker IDs that have activated the plugin to add these handlers to
+ */
+function addInterventionHandlers(handlers, trackers) {
+    var _a;
+    if (trackers === void 0) { trackers = Object.keys(instances); }
+    for (var _i = 0, trackers_2 = trackers; _i < trackers_2.length; _i++) {
+        var trackerId = trackers_2[_i];
+        handlerRegistry[trackerId] = Object.assign((_a = handlerRegistry[trackerId]) !== null && _a !== void 0 ? _a : {}, handlers);
+    }
+}
+/**
+ * Stop calling handlers with the given IDs with new interventions
+ * @param handlerIds One or more handler IDs to remove
+ * @param trackers List of trackers to remove the handlers for; defaults to all trackers that have activated the plugin.
+ */
+function removeInterventionHandlers(handlerIds, trackers) {
+    if (trackers === void 0) { trackers = Object.keys(instances); }
+    var toRemove = Array.isArray(handlerIds) ? handlerIds : [handlerIds];
+    for (var _i = 0, toRemove_1 = toRemove; _i < toRemove_1.length; _i++) {
+        var handlerId = toRemove_1[_i];
+        for (var _a = 0, trackers_3 = trackers; _a < trackers_3.length; _a++) {
+            var trackerId = trackers_3[_a];
+            delete handlerRegistry[trackerId][handlerId];
+        }
+    }
+}
+
+export { SignalsInterventionsPlugin, addInterventionHandlers, removeInterventionHandlers, subscribeToInterventions };
+//# sourceMappingURL=index.module.js.map