@ohos-ports/s-ui-segment-wrapper 0.0.0-stage → 5.4.0-beta.0

package/lib/repositories/googleRepository.js

@@ -0,0 +1,272 @@
+import _async_to_generator from "@swc/helpers/src/_async_to_generator.mjs";
+import _extends from "@swc/helpers/src/_extends.mjs";
+import _ts_generator from "@swc/helpers/src/_ts_generator.mjs";
+import { dispatchEvent } from "@s-ui/js/lib/events/index.js";
+import { getConfig } from "../config.js";
+import { EVENTS } from "../events.js";
+import { utils } from "../middlewares/source/pageReferrer.js";
+import { isGA4DestinationEnabled } from "../utils/ga4Detection.js";
+var FIELDS = {
+    clientId: "client_id",
+    sessionId: "session_id"
+};
+export var DEFAULT_DATA_LAYER_NAME = "dataLayer";
+export var CONSENT_STATES = {
+    granted: "granted",
+    denied: "denied"
+};
+var CONSENT_STATE_GRANTED_VALUE = 1;
+var CONSENT_STATE_DENIED_VALUE = 2;
+var STC = {
+    QUERY: "stc",
+    SPLIT_SYMBOL: "-",
+    CAMPAIGN_SPLIT_SYMBOL: ":"
+};
+var UTM_CAMPAIGN = "utm_campaign";
+var UTM_MEDIUM = "utm_medium";
+var UTM_SOURCE = "utm_source";
+var UTM_CONTENT = "utm_content";
+var UTM_CAMPAIGN_ID = "utm_id";
+var UTM_TERM = "utm_term";
+var STC_MEDIUM_TRANSFORMATIONS = {
+    aff: "affiliate",
+    dis: "display",
+    em: "email",
+    met: "paid-metasearch",
+    sem: "paid-search",
+    rt: "retargeting",
+    sm: "social-media",
+    sp: "paid-social",
+    pn: "push-notification",
+    cs: "cross-sites"
+};
+var STC_INVALID_CONTENT = "na";
+var DEFAULT_GA_INIT_EVENT = "sui";
+var EMPTY_STC = {
+    medium: null,
+    source: null,
+    campaign: null
+};
+var loadScript = /*#__PURE__*/ _async_to_generator(function(src) {
+    return _ts_generator(this, function(_state) {
+        return [
+            2,
+            new Promise(function(resolve, reject) {
+                var script = document.createElement("script");
+                script.src = src;
+                script.onload = resolve;
+                script.onerror = reject;
+                document.head.appendChild(script);
+            })
+        ];
+    });
+});
+export var loadGoogleAnalytics = /*#__PURE__*/ _async_to_generator(function() {
+    var googleAnalyticsMeasurementId, dataLayerName, gtagScript;
+    return _ts_generator(this, function(_state) {
+        googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+        dataLayerName = getConfig("googleAnalyticsDataLayer") || DEFAULT_DATA_LAYER_NAME;
+        // Check we have the needed config to load the script
+        if (!googleAnalyticsMeasurementId) return [
+            2,
+            Promise.resolve(false)
+        ];
+        gtagScript = "https://www.googletagmanager.com/gtag/js?id=" + googleAnalyticsMeasurementId + "&l=" + dataLayerName;
+        // Load it and retrieve the `clientId` from Google
+        return [
+            2,
+            loadScript(gtagScript)
+        ];
+    });
+});
+// Trigger GA init event just once per session.
+// Only in LEGACY mode (manual GA4 initialization)
+var triggerGoogleAnalyticsInitEvent = function(sessionId) {
+    // Don't trigger if using Segment destination (new mode)
+    if (isGA4DestinationEnabled()) return;
+    var ref;
+    var eventName = (ref = getConfig("googleAnalyticsInitEvent")) != null ? ref : DEFAULT_GA_INIT_EVENT;
+    var eventPrefix = "ga_event_" + eventName + "_";
+    var eventKey = "" + eventPrefix + sessionId;
+    if (typeof window.gtag === "undefined") return;
+    // Check if the event has already been sent in this session.
+    if (!localStorage.getItem(eventKey)) {
+        // If not, send it.
+        window.gtag("event", eventName);
+        // eslint-disable-next-line no-console
+        console.log('Sending GA4 event "' + eventName + '" for the session "' + sessionId + '"');
+        // And then save a new GA session hit in local storage.
+        localStorage.setItem(eventKey, "true");
+        dispatchEvent({
+            eventName: EVENTS.GA4_INIT_EVENT_SENT,
+            detail: {
+                eventName: eventName,
+                sessionId: sessionId
+            }
+        });
+    }
+    // Clean old GA sessions hits from the storage.
+    Object.keys(localStorage).forEach(function(key) {
+        if (key.startsWith(eventPrefix) && key !== eventKey) {
+            localStorage.removeItem(key);
+        }
+    });
+};
+var getGoogleField = /*#__PURE__*/ _async_to_generator(function(field) {
+    var googleAnalyticsMeasurementId;
+    return _ts_generator(this, function(_state) {
+        googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+        // If `googleAnalyticsMeasurementId` is not present, don't load anything.
+        if (!googleAnalyticsMeasurementId) return [
+            2,
+            Promise.resolve()
+        ];
+        return [
+            2,
+            new Promise(function(resolve) {
+                // If it is, get it from `gtag`.
+                window.gtag == null ? void 0 : window.gtag("get", googleAnalyticsMeasurementId, field, resolve);
+            })
+        ];
+    });
+});
+export var trackingTagsTypes = {
+    STC: "stc",
+    UTM: "utm"
+};
+export var getCampaignDetails = function(param) {
+    var ref = param === void 0 ? {} : param, _needsTransformation = ref.needsTransformation, needsTransformation = _needsTransformation === void 0 ? true : _needsTransformation;
+    var ref1 = readQueryParams(), medium = ref1.medium, source = ref1.source, campaign = ref1.campaign, content = ref1.content, term = ref1.term;
+    if (!medium || !source || !campaign) return null;
+    var ref2 = campaign.split(STC.CAMPAIGN_SPLIT_SYMBOL), id = ref2[0], name = ref2[1];
+    if (!id && !name) return null;
+    var needsContent = typeof content !== "undefined" && content !== STC_INVALID_CONTENT;
+    return {
+        campaign: _extends({
+            medium: needsTransformation && STC_MEDIUM_TRANSFORMATIONS[medium] || medium
+        }, typeof name !== "undefined" && {
+            id: id
+        }, {
+            name: name != null ? name : id,
+            source: source
+        }, needsContent && {
+            content: content
+        }, typeof term !== "undefined" && {
+            term: term
+        })
+    };
+};
+function readQueryParams() {
+    var search = utils.getActualQueryString();
+    var searchParams = new URLSearchParams(search);
+    return getConfig("trackingTagsType") === trackingTagsTypes.UTM ? readFromUtm(searchParams) : readFromStc(searchParams);
+}
+function readFromStc(searchParams) {
+    if (!hasStc(searchParams)) return EMPTY_STC;
+    var stc = searchParams.get(STC.QUERY);
+    var ref = stc.split(STC.SPLIT_SYMBOL), medium = ref[0], source = ref[1], campaign = ref[2], content = ref[3], term = ref[4];
+    return {
+        medium: medium,
+        source: source,
+        campaign: campaign,
+        content: content,
+        term: term
+    };
+}
+function hasStc(searchParams) {
+    return searchParams.has(STC.QUERY);
+}
+function readFromUtm(searchParams) {
+    var campaignId = searchParams.get(UTM_CAMPAIGN_ID);
+    var campaignName = searchParams.get(UTM_CAMPAIGN);
+    var medium = searchParams.get(UTM_MEDIUM);
+    var source = searchParams.get(UTM_SOURCE);
+    var content = searchParams.get(UTM_CONTENT);
+    var term = searchParams.get(UTM_TERM);
+    var campaign = campaignId ? "" + campaignId + STC.CAMPAIGN_SPLIT_SYMBOL + campaignName : campaignName;
+    // Fallback to STC if any mandatory UTM fields are missing
+    var missingAnyMandatoryFields = !medium || !source || !campaign;
+    if (missingAnyMandatoryFields && hasStc(searchParams)) {
+        return readFromStc(searchParams);
+    }
+    return {
+        campaign: campaign,
+        medium: medium,
+        source: source,
+        content: content,
+        term: term
+    };
+}
+export var getGoogleClientId = /*#__PURE__*/ _async_to_generator(function() {
+    return _ts_generator(this, function(_state) {
+        return [
+            2,
+            getGoogleField(FIELDS.clientId)
+        ];
+    });
+});
+export var getGoogleSessionId = /*#__PURE__*/ _async_to_generator(function() {
+    var sessionId;
+    return _ts_generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                return [
+                    4,
+                    getGoogleField(FIELDS.sessionId)
+                ];
+            case 1:
+                sessionId = _state.sent();
+                triggerGoogleAnalyticsInitEvent(sessionId);
+                return [
+                    2,
+                    sessionId
+                ];
+        }
+    });
+});
+// Unified consent state getter.
+// Returns GRANTED, DENIED or undefined (default / unknown / unavailable).
+export function getGoogleConsentValue(consentType) {
+    if (consentType === void 0) consentType = "analytics_storage";
+    try {
+        var ref, ref1;
+        var value = (ref = window.google_tag_data) == null ? void 0 : (ref1 = ref.ics) == null ? void 0 : ref1.getConsentState == null ? void 0 : ref1.getConsentState(consentType);
+        if (value === CONSENT_STATE_GRANTED_VALUE) return CONSENT_STATES.granted;
+        if (value === CONSENT_STATE_DENIED_VALUE) return CONSENT_STATES.denied;
+        return undefined;
+    } catch (error) {
+        // GTM bug when first rejection happens: keep default undefined instead of forcing DENIED
+        return undefined;
+    }
+}
+var ref;
+// Backwards compatibility alias (previous getConsentState behavior now unified but default is undefined)
+export var getConsentState = function() {
+    return (ref = getGoogleConsentValue()) != null ? ref : CONSENT_STATES.denied;
+};
+export var setGoogleUserId = function(userId) {
+    var googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+    if (!googleAnalyticsMeasurementId || !userId) return;
+    window.gtag == null ? void 0 : window.gtag("set", "user_id", userId);
+};
+/**
+ * Send consents to Google Consent Mode.
+ *
+ * @param {'default' | 'update'} mode Mode for the consent update
+ * @param {object} consents Consents object to be sent to Google Consent Mode.
+ * Defaults used when not provided:
+ * {
+ *   analytics_storage: 'denied',
+ *   ad_user_data: 'denied',
+ *   ad_personalization: 'denied',
+ *   ad_storage: 'denied'
+ * }
+ */ export var sendGoogleConsents = function(mode, consents) {
+    if (mode === void 0) mode = "default";
+    window.gtag == null ? void 0 : window.gtag("consent", mode, consents || {
+        analytics_storage: CONSENT_STATES.denied,
+        ad_user_data: CONSENT_STATES.denied,
+        ad_personalization: CONSENT_STATES.denied,
+        ad_storage: CONSENT_STATES.denied
+    });
+};

package/lib/repositories/xandrRepository.js

@@ -0,0 +1,42 @@
+import { readCookie, removeCookie, saveCookie } from "../utils/cookies.js";
+import { isClient, setConfig } from "../config.js";
+import { USER_GDPR } from "../tcf.js";
+var XANDR_ID_SERVER_URL = "https://secure.adnxs.com/getuidj?consent=1";
+var XANDR_ID_COOKIE = "adit-xandr-id";
+var USER_OPTED_OUT_XANDR_ID_VALUE = 0;
+/**
+ * [Xandr API Docs]{@link https://docs.xandr.com/bundle/invest_invest-standard/page/topics/user-id-mapping-with-getuid-and-mapuid.html}
+ * @returns {String|null} a valid xandrId value
+ */ export function getXandrId(param) {
+    var gdprPrivacyValueAdvertising = param.gdprPrivacyValueAdvertising;
+    if (!isClient) return null;
+    if (gdprPrivacyValueAdvertising !== USER_GDPR.ACCEPTED) {
+        removeCookie(XANDR_ID_COOKIE);
+        return null;
+    }
+    // 0 is invalid. Negative numbers seems to be invalid too.
+    var checkValid = function(xandrId) {
+        return xandrId && Number(xandrId) > USER_OPTED_OUT_XANDR_ID_VALUE;
+    };
+    var storedXandrId = readCookie(XANDR_ID_COOKIE);
+    var isValidXandrId = checkValid(storedXandrId);
+    if (!isValidXandrId) {
+        getRemoteXandrId().then(function(xandrId) {
+            if (typeof xandrId === "string") {
+                saveCookie(XANDR_ID_COOKIE, xandrId);
+            }
+        });
+    }
+    setConfig("xandrId", storedXandrId);
+    return isValidXandrId ? storedXandrId : null;
+}
+function getRemoteXandrId() {
+    if (!isClient) return Promise.resolve(null);
+    return window.fetch(XANDR_ID_SERVER_URL, {
+        credentials: "include"
+    }).then(function(response) {
+        return response.json();
+    }).then(function(json) {
+        return json == null ? void 0 : json.uid;
+    });
+}

package/lib/segmentWrapper.js

@@ -0,0 +1,364 @@
+// @ts-check
+import _async_to_generator from "@swc/helpers/src/_async_to_generator.mjs";
+import _extends from "@swc/helpers/src/_extends.mjs";
+import _to_consumable_array from "@swc/helpers/src/_to_consumable_array.mjs";
+import _ts_generator from "@swc/helpers/src/_ts_generator.mjs";
+import { CONSENT_STATES, getConsentState, getGoogleClientId, getGoogleConsentValue, getGoogleSessionId, sendGoogleConsents, setGoogleUserId } from "./repositories/googleRepository.js";
+import { getXandrId } from "./repositories/xandrRepository.js";
+import { getConfig } from "./config.js";
+import { USER_GDPR, CMP_TRACK_EVENT, checkAnalyticsGdprIsAccepted, getGdprPrivacyValue } from "./tcf.js";
+import { isGA4DestinationEnabled } from "./utils/ga4Detection.js";
+/* Default properties to be sent on all trackings */ var DEFAULT_PROPERTIES = {
+    platform: "web"
+};
+/* Disabled integrations when no GDPR Privacy Value is true */ export var INTEGRATIONS_WHEN_NO_CONSENTS = {
+    All: false
+};
+export var INTEGRATIONS_WHEN_NO_CONSENTS_CMP_SUBMITTED = {
+    All: true
+};
+var getUserId = function(userId) {
+    var prefix = getConfig("userIdPrefix");
+    if (!prefix) {
+        return userId;
+    }
+    if (typeof userId === "number" || typeof userId === "string" && !userId.startsWith(prefix)) {
+        return "" + prefix + userId;
+    }
+    return userId;
+};
+/**
+ * Get default properties using the constant and the window.__mpi object if available
+ * @returns {{[key:string]: any}} Default properties to attach to track
+ */ export var getDefaultProperties = function() {
+    return _extends({}, DEFAULT_PROPERTIES, getConfig("defaultProperties"));
+};
+/**
+ * Get all needed integrations depending on the gdprPrivacy value.
+ * @param {object} param - Object with the gdprPrivacyValue and if it's a CMP Submitted event
+ */ var getTrackIntegrations = /*#__PURE__*/ _async_to_generator(function(param) {
+    var gdprPrivacyValue, event, isGdprAccepted, restOfIntegrations, useSegmentGA4Destination, sessionId, clientId, error;
+    return _ts_generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                gdprPrivacyValue = param.gdprPrivacyValue, event = param.event;
+                isGdprAccepted = checkAnalyticsGdprIsAccepted(gdprPrivacyValue);
+                restOfIntegrations = getRestOfIntegrations({
+                    isGdprAccepted: isGdprAccepted,
+                    event: event
+                });
+                useSegmentGA4Destination = isGA4DestinationEnabled();
+                if (useSegmentGA4Destination) {
+                    // New behavior: let Segment handle GA4
+                    return [
+                        2,
+                        _extends({}, restOfIntegrations, {
+                            "Google Analytics 4 Web": true
+                        })
+                    ];
+                }
+                _state.label = 1;
+            case 1:
+                _state.trys.push([
+                    1,
+                    4,
+                    ,
+                    5
+                ]);
+                return [
+                    4,
+                    getGoogleSessionId()
+                ];
+            case 2:
+                sessionId = _state.sent();
+                return [
+                    4,
+                    getGoogleClientId()
+                ];
+            case 3:
+                clientId = _state.sent();
+                return [
+                    3,
+                    5
+                ];
+            case 4:
+                error = _state.sent();
+                console.error("[segment-wrapper] Failed to retrieve GA4 session/client IDs. Events will be sent without session attribution.", error);
+                return [
+                    3,
+                    5
+                ];
+            case 5:
+                return [
+                    2,
+                    _extends({}, restOfIntegrations, {
+                        "Google Analytics 4": clientId && sessionId ? {
+                            clientId: clientId,
+                            sessionId: sessionId
+                        } : true
+                    })
+                ];
+        }
+    });
+});
+/**
+ * Get Rest of integrations depending on the gdprPrivacy value and if it's a CMP Submitted event
+ * @param {object} param - Object with the isGdprAccepted and if it's a CMP Submitted event
+ * @returns {object} integrations
+ */ export var getRestOfIntegrations = function(param) {
+    var isGdprAccepted = param.isGdprAccepted, event = param.event;
+    var isCMPSubmittedEvent = event === "CMP Submitted";
+    if (isCMPSubmittedEvent) {
+        return INTEGRATIONS_WHEN_NO_CONSENTS_CMP_SUBMITTED;
+    }
+    return isGdprAccepted ? {} : INTEGRATIONS_WHEN_NO_CONSENTS;
+};
+/**
+ * It returns externalIds to add to context
+ *
+ * @param {Object} param
+ * @param {Object} param.context previous context
+ * @param {String} param.xandrId xandrId to be included
+ * @returns
+ */ var getExternalIds = function(param) {
+    var context = param.context, xandrId = param.xandrId;
+    var shouldSendXandrId = getConfig("sendXandrId") !== false;
+    var isValidXandrId = xandrId && parseInt(xandrId) !== 0;
+    if (!shouldSendXandrId || !isValidXandrId) {
+        return {};
+    }
+    var SEGMENT_COLLECTION = "users";
+    var SEGMENT_ENCODING = "none";
+    var SEGMENT_TYPE = "xandr_id";
+    var externalIds = _to_consumable_array((context == null ? void 0 : context.externalIds) || []).concat([
+        {
+            collection: SEGMENT_COLLECTION,
+            encoding: SEGMENT_ENCODING,
+            id: xandrId,
+            type: SEGMENT_TYPE
+        }
+    ]);
+    var uniqueExternalIds = externalIds.filter(function(param, index) {
+        var idFilter = param.id, typeFilter = param.type;
+        return index === externalIds.findIndex(function(param) {
+            var idFind = param.id, typeFind = param.type;
+            return idFilter === idFind && typeFilter === typeFind;
+        });
+    });
+    return {
+        externalIds: uniqueExternalIds
+    };
+};
+/**
+ * Get consent value for Google Consent Mode
+ * @param {string} gdprValue
+ * @returns {string} consent value
+ */ var getConsentValue = function(gdprValue) {
+    return gdprValue === USER_GDPR.ACCEPTED ? CONSENT_STATES.granted : CONSENT_STATES.denied;
+};
+/**
+ * Get data like traits and integrations to be added to the context object
+ * @param {object} context Context object with all the actual info
+ * @returns {Promise<object>} New context with all the previous info and the new one
+ */ export var decorateContextWithNeededData = /*#__PURE__*/ _async_to_generator(function(param) {
+    var _event, event, _context, context, _properties, properties, gdprPrivacyValue, ref, gdprPrivacyValueAnalytics, gdprPrivacyValueAdvertising, isGdprAccepted, useSegmentGA4Destination, ref1, integrations, xandrId, _integrations, contextIntegrations, ref2, ref3, ref4, ref5, googleConsents, _VERSION, baseContext;
+    return _ts_generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                _event = param.event, event = _event === void 0 ? "" : _event, _context = param.context, context = _context === void 0 ? {} : _context, _properties = param.properties, properties = _properties === void 0 ? {} : _properties;
+                return [
+                    4,
+                    getGdprPrivacyValue()
+                ];
+            case 1:
+                gdprPrivacyValue = _state.sent();
+                ref = gdprPrivacyValue || {}, gdprPrivacyValueAnalytics = ref.analytics, gdprPrivacyValueAdvertising = ref.advertising;
+                isGdprAccepted = checkAnalyticsGdprIsAccepted(gdprPrivacyValue);
+                useSegmentGA4Destination = isGA4DestinationEnabled();
+                return [
+                    4,
+                    Promise.all([
+                        getTrackIntegrations({
+                            gdprPrivacyValue: gdprPrivacyValue,
+                            event: event
+                        }),
+                        getXandrId({
+                            gdprPrivacyValueAdvertising: gdprPrivacyValueAdvertising
+                        })
+                    ])
+                ];
+            case 2:
+                ref1 = _state.sent(), integrations = ref1[0], xandrId = ref1[1];
+                contextIntegrations = !isGdprAccepted ? _extends({}, (_integrations = context.integrations) != null ? _integrations : {}, {
+                    Personas: false,
+                    Webhooks: true,
+                    Webhook: true
+                }) : context.integrations;
+                googleConsents = {
+                    analytics_storage: useSegmentGA4Destination ? getConsentValue(gdprPrivacyValueAnalytics) : (ref2 = getGoogleConsentValue("analytics_storage")) != null ? ref2 : getConsentValue(gdprPrivacyValueAnalytics),
+                    ad_storage: useSegmentGA4Destination ? getConsentValue(gdprPrivacyValueAdvertising) : (ref3 = getGoogleConsentValue("ad_storage")) != null ? ref3 : getConsentValue(gdprPrivacyValueAdvertising),
+                    ad_user_data: useSegmentGA4Destination ? getConsentValue(gdprPrivacyValueAdvertising) : (ref4 = getGoogleConsentValue("ad_user_data")) != null ? ref4 : getConsentValue(gdprPrivacyValueAdvertising),
+                    ad_personalization: useSegmentGA4Destination ? getConsentValue(gdprPrivacyValueAdvertising) : (ref5 = getGoogleConsentValue("ad_personalization")) != null ? ref5 : getConsentValue(gdprPrivacyValueAdvertising)
+                };
+                baseContext = _extends({}, context, !isGdprAccepted && {
+                    ip: "0.0.0.0"
+                }, getExternalIds({
+                    context: context,
+                    xandrId: xandrId
+                }), {
+                    clientVersion: "segment-wrapper@" + ((_VERSION = "5.4.0") != null ? _VERSION : "0.0.0"),
+                    gdpr_privacy: gdprPrivacyValueAnalytics,
+                    gdpr_privacy_advertising: gdprPrivacyValueAdvertising,
+                    integrations: _extends({}, contextIntegrations, integrations)
+                });
+                // Legacy behavior: add analytics_storage and google_consents to context
+                if (!useSegmentGA4Destination) {
+                    baseContext.analytics_storage = getConsentState();
+                    baseContext.google_consents = googleConsents;
+                }
+                return [
+                    2,
+                    {
+                        context: baseContext,
+                        properties: useSegmentGA4Destination ? _extends({}, properties, {
+                            // New mode: add google_consents to properties
+                            google_consents: googleConsents
+                        }) : properties
+                    }
+                ];
+        }
+    });
+});
+/**
+ * The track method lets you record any actions your users perform.
+ * @param {string} event The name of the event you’re tracking
+ * @param {object} [properties] A dictionary of properties for the event.
+ * @param {object} [context] A dictionary of options.
+ * @param {function} [callback] A function executed after a short timeout, giving the browser time to make outbound requests first.
+ * @returns {Promise}
+ */ var track = function(event, properties, context, callback) {
+    if (context === void 0) context = {};
+    return new Promise(function(resolve) {
+        var initTrack = /*#__PURE__*/ _async_to_generator(function() {
+            var baseProperties, ref, newContext, decoratedProperties, newCallback, useSegmentGA4Destination, needsConsentManagement;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        baseProperties = _extends({}, getDefaultProperties(), properties);
+                        return [
+                            4,
+                            decorateContextWithNeededData({
+                                context: context,
+                                event: event,
+                                properties: baseProperties
+                            })
+                        ];
+                    case 1:
+                        ref = _state.sent(), newContext = ref.context, decoratedProperties = ref.properties;
+                        newCallback = /*#__PURE__*/ _async_to_generator(function() {
+                            var _len, args, _key, ref, gdprPrivacyValue;
+                            var _arguments = arguments;
+                            return _ts_generator(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        for(_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                                            args[_key] = _arguments[_key];
+                                        }
+                                        if (callback) callback.apply(void 0, args) // eslint-disable-line n/no-callback-literal
+                                        ;
+                                        return [
+                                            4,
+                                            Promise.all([
+                                                getGdprPrivacyValue()
+                                            ])
+                                        ];
+                                    case 1:
+                                        ref = _state.sent(), gdprPrivacyValue = ref[0];
+                                        if (checkAnalyticsGdprIsAccepted(gdprPrivacyValue)) {
+                                            resolve.apply(void 0, args);
+                                        } else {
+                                            resolve();
+                                        }
+                                        return [
+                                            2
+                                        ];
+                                }
+                            });
+                        });
+                        useSegmentGA4Destination = isGA4DestinationEnabled();
+                        needsConsentManagement = getConfig("googleAnalyticsConsentManagement");
+                        // Legacy behavior: send consents to GTM
+                        if (!useSegmentGA4Destination && needsConsentManagement && event === CMP_TRACK_EVENT) {
+                            sendGoogleConsents("update", newContext.google_consents);
+                        }
+                        window.analytics.track(event, decoratedProperties, _extends({}, newContext, {
+                            context: {
+                                integrations: _extends({}, newContext.integrations)
+                            }
+                        }), newCallback);
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        initTrack();
+    });
+};
+/**
+ * Associate your users and their actions to a recognizable userId and traits.
+ * @param {string} userIdParam Id to identify the user.
+ * @param {object} traits A dictionary of traits you know about the user, like their email or name.
+ * @param {object} [options] A dictionary of options.
+ * @param {function} [callback] A function executed after a short timeout, giving the browser time to make outbound requests first.
+ * @returns {Promise}
+ */ var identify = /*#__PURE__*/ _async_to_generator(function(userIdParam, traits, options, callback) {
+    var gdprPrivacyValue, userId;
+    return _ts_generator(this, function(_state) {
+        switch(_state.label){
+            case 0:
+                return [
+                    4,
+                    getGdprPrivacyValue()
+                ];
+            case 1:
+                gdprPrivacyValue = _state.sent();
+                userId = getUserId(userIdParam);
+                // Legacy behavior: set user ID in gtag
+                if (!isGA4DestinationEnabled()) {
+                    setGoogleUserId(userId);
+                }
+                return [
+                    2,
+                    window.analytics.identify(userId, checkAnalyticsGdprIsAccepted(gdprPrivacyValue) ? traits : {}, options, callback)
+                ];
+        }
+    });
+});
+/**
+ * Record whenever a user sees a page of your website, along with any optional properties about the page.
+ * @param {string} event The name of the event you’re tracking
+ * @param {object=} properties A dictionary of properties for the event.
+ * @param {object} [context] A dictionary of options.
+ * @param {function} [callback] A function executed after a short timeout, giving the browser time to make outbound requests first.
+ * @returns {Promise}
+ */ var page = function(event, properties, context, callback) {
+    if (context === void 0) context = {};
+    // we put a flag on context to know this track is a page
+    context.isPageTrack = true;
+    // just call track again but the with the proper context
+    return track(event, properties, context, callback);
+};
+/**
+ * Resets the id, including anonymousId, and clear traits for the currently identified user and group.
+ * NOTE: Only clears the cookies and localStorage set by analytics.
+ * @returns {Promise}
+ */ var reset = function() {
+    return Promise.resolve(window.analytics.reset());
+};
+export default {
+    page: page,
+    identify: identify,
+    track: track,
+    reset: reset
+};