@snowplow/signals-browser-plugin 0.0.1

package/dist/index.umd.js

@@ -0,0 +1,951 @@
+/*!
+ * 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
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.snowplowSignals = {}));
+})(this, (function (exports) { 'use strict';
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    /*!
+     * Core functionality for Snowplow JavaScript trackers v4.6.5 (http://bit.ly/sp-js)
+     * Copyright 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+     * Licensed under BSD-3-Clause
+     */
+
+
+    /*
+     * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+     * All rights reserved.
+     *
+     * Redistribution and use in source and binary forms, with or without
+     * modification, are permitted provided that the following conditions are met:
+     *
+     * 1. Redistributions of source code must retain the above copyright notice, this
+     *    list of conditions and the following disclaimer.
+     *
+     * 2. Redistributions in binary form must reproduce the above copyright notice,
+     *    this list of conditions and the following disclaimer in the documentation
+     *    and/or other materials provided with the distribution.
+     *
+     * 3. Neither the name of the copyright holder nor the names of its
+     *    contributors may be used to endorse or promote products derived from
+     *    this software without specific prior written permission.
+     *
+     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+     * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+     * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+     * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+     * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+     * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+     */
+    function payloadBuilder() {
+        var dict = {}, allJson = [], jsonForProcessing = [], contextEntitiesForProcessing = [];
+        var processor;
+        var add = function (key, value) {
+            if (value != null && value !== '') {
+                // null also checks undefined
+                dict[key] = value;
+            }
+        };
+        var addDict = function (dict) {
+            for (var key in dict) {
+                if (Object.prototype.hasOwnProperty.call(dict, key)) {
+                    add(key, dict[key]);
+                }
+            }
+        };
+        var addJson = function (keyIfEncoded, keyIfNotEncoded, json) {
+            if (json && isNonEmptyJson(json)) {
+                var jsonWithKeys = { keyIfEncoded: keyIfEncoded, keyIfNotEncoded: keyIfNotEncoded, json: json };
+                jsonForProcessing.push(jsonWithKeys);
+                allJson.push(jsonWithKeys);
+            }
+        };
+        var addContextEntity = function (entity) {
+            contextEntitiesForProcessing.push(entity);
+        };
+        return {
+            add: add,
+            addDict: addDict,
+            addJson: addJson,
+            addContextEntity: addContextEntity,
+            getPayload: function () { return dict; },
+            getJson: function () { return allJson; },
+            withJsonProcessor: function (jsonProcessor) {
+                processor = jsonProcessor;
+            },
+            build: function () {
+                processor === null || processor === void 0 ? void 0 : processor(this, jsonForProcessing, contextEntitiesForProcessing);
+                return dict;
+            },
+        };
+    }
+    /**
+     * Is property a non-empty JSON?
+     * @param property - Checks if object is non-empty json
+     */
+    function isNonEmptyJson(property) {
+        if (!isJson(property)) {
+            return false;
+        }
+        for (var key in property) {
+            if (Object.prototype.hasOwnProperty.call(property, key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Is property a JSON?
+     * @param property - Checks if object is json
+     */
+    function isJson(property) {
+        return (typeof property !== 'undefined' &&
+            property !== null &&
+            (property.constructor === {}.constructor || property.constructor === [].constructor));
+    }
+
+    /*
+     * Copyright (c) 2022 Snowplow Analytics Ltd, 2010 Anthon Pang
+     * All rights reserved.
+     *
+     * Redistribution and use in source and binary forms, with or without
+     * modification, are permitted provided that the following conditions are met:
+     *
+     * 1. Redistributions of source code must retain the above copyright notice, this
+     *    list of conditions and the following disclaimer.
+     *
+     * 2. Redistributions in binary form must reproduce the above copyright notice,
+     *    this list of conditions and the following disclaimer in the documentation
+     *    and/or other materials provided with the distribution.
+     *
+     * 3. Neither the name of the copyright holder nor the names of its
+     *    contributors may be used to endorse or promote products derived from
+     *    this software without specific prior written permission.
+     *
+     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+     * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+     * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+     * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+     * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+     * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+     * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+     * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+     * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+     */
+    var label = 'Snowplow: ';
+    var LOG_LEVEL;
+    (function (LOG_LEVEL) {
+        LOG_LEVEL[LOG_LEVEL["none"] = 0] = "none";
+        LOG_LEVEL[LOG_LEVEL["error"] = 1] = "error";
+        LOG_LEVEL[LOG_LEVEL["warn"] = 2] = "warn";
+        LOG_LEVEL[LOG_LEVEL["debug"] = 3] = "debug";
+        LOG_LEVEL[LOG_LEVEL["info"] = 4] = "info";
+    })(LOG_LEVEL || (LOG_LEVEL = {}));
+    logger$1();
+    function logger$1(logLevel) {
+        if (logLevel === void 0) { logLevel = LOG_LEVEL.warn; }
+        function setLogLevel(level) {
+            if (LOG_LEVEL[level]) {
+                logLevel = level;
+            }
+            else {
+                logLevel = LOG_LEVEL.warn;
+            }
+        }
+        /**
+         * Log errors, with or without error object
+         */
+        function error(message, error) {
+            var extraParams = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                extraParams[_i - 2] = arguments[_i];
+            }
+            if (logLevel >= LOG_LEVEL.error && typeof console !== 'undefined') {
+                var logMsg = label + message + '\n';
+                if (error) {
+                    console.error.apply(console, __spreadArray([logMsg + '\n', error], extraParams, false));
+                }
+                else {
+                    console.error.apply(console, __spreadArray([logMsg], extraParams, false));
+                }
+            }
+        }
+        /**
+         * Log warnings, with or without error object
+         */
+        function warn(message, error) {
+            var extraParams = [];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                extraParams[_i - 2] = arguments[_i];
+            }
+            if (logLevel >= LOG_LEVEL.warn && typeof console !== 'undefined') {
+                var logMsg = label + message;
+                if (error) {
+                    console.warn.apply(console, __spreadArray([logMsg + '\n', error], extraParams, false));
+                }
+                else {
+                    console.warn.apply(console, __spreadArray([logMsg], extraParams, false));
+                }
+            }
+        }
+        /**
+         * Log debug messages
+         */
+        function debug(message) {
+            var extraParams = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                extraParams[_i - 1] = arguments[_i];
+            }
+            if (logLevel >= LOG_LEVEL.debug && typeof console !== 'undefined') {
+                console.debug.apply(console, __spreadArray([label + message], extraParams, false));
+            }
+        }
+        /**
+         * Log info messages
+         */
+        function info(message) {
+            var extraParams = [];
+            for (var _i = 1; _i < arguments.length; _i++) {
+                extraParams[_i - 1] = arguments[_i];
+            }
+            if (logLevel >= LOG_LEVEL.info && typeof console !== 'undefined') {
+                console.info.apply(console, __spreadArray([label + message], extraParams, false));
+            }
+        }
+        return { setLogLevel: setLogLevel, warn: warn, error: error, debug: debug, info: info };
+    }
+    /**
+     * Find dynamic context generating functions and return their results to be merged into the static contexts
+     * Combine an array of unchanging contexts with the result of a context-creating function
+     *
+     * @param dynamicOrStaticContexts - Array of custom context Objects or custom context generating functions
+     * @param Parameters - to pass to dynamic context callbacks
+     * @returns An array of Self Describing JSON context
+     */
+    function resolveDynamicContext(dynamicOrStaticContexts) {
+        var _a;
+        var extraParams = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            extraParams[_i - 1] = arguments[_i];
+        }
+        return ((_a = dynamicOrStaticContexts === null || dynamicOrStaticContexts === void 0 ? void 0 : dynamicOrStaticContexts.map(function (context) {
+            if (typeof context === 'function') {
+                try {
+                    return context.apply(void 0, extraParams);
+                }
+                catch (e) {
+                    //TODO: provide warning
+                    return undefined;
+                }
+            }
+            else {
+                return context;
+            }
+        }).filter(Boolean)) !== null && _a !== void 0 ? _a : []);
+    }
+    /**
+     * Build a self-describing event
+     * A custom event type, allowing for an event to be tracked using your own custom schema
+     * and a data object which conforms to the supplied schema
+     *
+     * @param event - Contains the properties and schema location for the event
+     * @returns PayloadBuilder to be sent to {@link @snowplow/tracker-core#TrackerCore.track}
+     */
+    function buildSelfDescribingEvent(event) {
+        var _a = event.event, schema = _a.schema, data = _a.data, pb = payloadBuilder();
+        var ueJson = {
+            schema: 'iglu:com.snowplowanalytics.snowplow/unstruct_event/jsonschema/1-0-0',
+            data: { schema: schema, data: data },
+        };
+        pb.add('e', 'ue');
+        pb.addJson('ue_px', 'ue_pr', ueJson);
+        return pb;
+    }
+
+    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];
+            }
+        }
+    }
+
+    exports.SignalsInterventionsPlugin = SignalsInterventionsPlugin;
+    exports.addInterventionHandlers = addInterventionHandlers;
+    exports.removeInterventionHandlers = removeInterventionHandlers;
+    exports.subscribeToInterventions = subscribeToInterventions;
+
+}));
+//# sourceMappingURL=index.umd.js.map