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

package/lib/tcf.js

@@ -0,0 +1,230 @@
+import _extends from "@swc/helpers/src/_extends.mjs";
+import { getConfig, isClient, setConfig } from "./config.js";
+import analytics from "./segmentWrapper.js";
+/**
+ * Cookie to extract the already saved consents for the user
+ * @type {string}
+ */ var TCF_COOKIE_KEY = "borosTcf";
+/**
+ * TCF Api Version to use
+ * @type {number}
+ */ var TCF_API_VERSION = 2;
+/**
+ * Default properties to send with every TCF tracking event
+ */ var TCF_TRACK_PROPERTIES = {
+    channel: "GDPR"
+};
+/**
+ * List of purpose ids needed to be able to track with all info
+ * @type {Array<number>}
+ */ var NEEDED_PURPOSES = {
+    analytics: [
+        1,
+        8,
+        10
+    ],
+    advertising: [
+        3
+    ]
+};
+/**
+ * TCF events
+ */ var TCF_EVENTS = {
+    // Event that determines that the tcData has been loaded
+    LOADED: "tcloaded",
+    // Event that determines that the user has performed an action
+    USER_ACTION_COMPLETE: "useractioncomplete"
+};
+export var CMP_TRACK_EVENT = "CMP Submitted";
+/**
+ * State of user according to GDPR regarding tracking
+ */ export var USER_GDPR = {
+    ACCEPTED: "accepted",
+    DECLINED: "declined",
+    UNKNOWN: "unknown"
+};
+/**
+ * Define the user GDPR consents state. This value will be updated with new values
+ * when the consents of the users changes.
+ */ var gdprState = {
+    listeners: [],
+    value: undefined,
+    addListener: function(callback) {
+        return gdprState.listeners.push(callback);
+    },
+    get: function() {
+        return gdprState.value;
+    },
+    set: function(value) {
+        var ref = value || {}, analytics = ref.analytics, advertising = ref.advertising;
+        gdprState.value = {
+            analytics: analytics,
+            advertising: advertising
+        };
+        gdprState.listeners.forEach(function(fn) {
+            return fn(value);
+        });
+        gdprState.listeners = [];
+    }
+};
+/**
+ * Read cookie by using a key
+ * @returns {string}
+ */ function readCookie(key) {
+    var re = new RegExp(key + "=([^;]+)");
+    var value = re.exec(document.cookie);
+    return value !== null ? unescape(value[1]) : null;
+}
+/**
+ * Check if we're on client and tcfApi is available on window object
+ * @returns {Boolean}
+ */ var checkTcfIsAvailable = function() {
+    // if we're on the client, check we haven't already initialized it
+    if (getConfig("initialized")) return false;
+    // if we're on client, check if we have the tcfapi available
+    var isTcfApiAvailable = !!window.__tcfapi;
+    !isTcfApiAvailable && console.warn("[tcfTracking] window.__tcfapi is not available on client and TCF won't be tracked.");
+    return isTcfApiAvailable;
+};
+/**
+ * Check from a list of consents if user has accepted being tracked
+ * @param {{[purposeId: string]: boolean}} userConsents
+ * @returns {Boolean}
+ */ var checkHasUserConsentedAnalytics = function(userConsents) {
+    return NEEDED_PURPOSES.analytics.every(function(purposeId) {
+        return userConsents["" + purposeId];
+    });
+};
+var checkHasUserConsentedAdvertising = function(userConsents) {
+    return NEEDED_PURPOSES.advertising.every(function(purposeId) {
+        return userConsents["" + purposeId];
+    });
+};
+/**
+ * Track a specific TCF event
+ * @param {object} params
+ * @param {string} params.eventId Event ID to be sent with the TCF Tracking
+ * @param {string} params.gdprPrivacy Send a string telling if the gdpr has been accepted or reject
+ * @return {Promise}
+ */ var trackTcf = function(param) {
+    var eventId = param.eventId, gdprPrivacy = param.gdprPrivacy;
+    return analytics.track(CMP_TRACK_EVENT, _extends({}, TCF_TRACK_PROPERTIES, getConfig("tcfTrackDefaultProperties")), {
+        gdpr_privacy: gdprPrivacy.analytics,
+        gdpr_privacy_advertising: gdprPrivacy.advertising
+    });
+};
+/**
+ * Get if we have user consents
+ * @return {Promise<Object>}
+ */ export var getGdprPrivacyValue = function() {
+    // try to get the actual gdprPrivacyValue and just return it
+    var gdprPrivacyValue = gdprState.get();
+    if (gdprPrivacyValue !== undefined) return Promise.resolve(gdprPrivacyValue);
+    // // if we don't have a gdprPrivacyValue, then subscribe to it until we have a value
+    return new Promise(function(resolve) {
+        gdprState.addListener(function(gdprPrivacyValue) {
+            return resolve(gdprPrivacyValue);
+        });
+    });
+};
+/**
+ * Check if gdprPrivacyValue is accepted
+ * @return {boolean}
+ */ export var checkAnalyticsGdprIsAccepted = function(gdprPrivacyValue) {
+    return gdprPrivacyValue.analytics === USER_GDPR.ACCEPTED;
+};
+/**
+ * Set gdprState according to list of purpose consents
+ * @returns {string}
+ */ var setGdprStateBy = function(purposeConsents) {
+    var hasAnalyticsConsents = checkHasUserConsentedAnalytics(purposeConsents);
+    var hasAdvertisingConsents = checkHasUserConsentedAdvertising(purposeConsents);
+    // get the state key according to the gdprPrivacyValue
+    var gdprAnalyticsStateKey = hasAnalyticsConsents ? USER_GDPR.ACCEPTED : USER_GDPR.DECLINED;
+    var gdprAdvertisingStateKey = hasAdvertisingConsents ? USER_GDPR.ACCEPTED : USER_GDPR.DECLINED;
+    // update gdprState with the new value for user gdpr
+    gdprState.set({
+        analytics: gdprAnalyticsStateKey,
+        advertising: gdprAdvertisingStateKey
+    });
+    // return the new gdprState
+    return {
+        analytics: gdprAnalyticsStateKey,
+        advertising: gdprAdvertisingStateKey
+    };
+};
+/**
+ * Read and decode the tcf cookie
+ */ var getConsentsFromCookie = function() {
+    var cookieValue = readCookie(TCF_COOKIE_KEY);
+    if (!cookieValue) return;
+    try {
+        var purpose = JSON.parse(window.atob(cookieValue)).purpose;
+        var consents = purpose.consents;
+        return consents;
+    } catch (e) {
+        console.error(e);
+    }
+};
+/**
+ * Set the correct initial gdprState based on the consents cookie string
+ */ var initializeGdprState = function() {
+    var consents = getConsentsFromCookie();
+    if (consents) setGdprStateBy(consents);
+};
+/**
+ * Sets global isFirstVisit flag based on the consents cookie string
+ */ var initializeIsFirstVisit = function() {
+    var consents = getConsentsFromCookie();
+    setConfig("isFirstVisit", !consents);
+};
+/**
+ * Init TCF Tracking User Consents with Segment
+ */ export default function initTcfTracking() {
+    // first check if we're on server, as this doesn't work on server-side
+    if (!isClient) return;
+    // read the cookie and put the correct usergdprValue and isFirstVisit flag before listening events
+    initializeGdprState();
+    initializeIsFirstVisit();
+    // do some checks before initializing tcf tracking as we do that only if available
+    if (!checkTcfIsAvailable()) {
+        var ref;
+        // if we don't have a gdpr state and tcf is not available
+        // we should assume we don't known if we have consents
+        var analyticsGdprState = (ref = gdprState.get()) == null ? void 0 : ref.analytics;
+        if (analyticsGdprState === undefined) gdprState.set({
+            analytics: USER_GDPR.UNKNOWN,
+            advertising: USER_GDPR.UNKNOWN
+        });
+        // and we stop executing as we can't track tcf
+        return;
+    }
+    // add a flag to the segmentWrapper config to know it's already initialized
+    setConfig("initialized", true);
+    // listen events from tcf api
+    window.__tcfapi("addEventListener", TCF_API_VERSION, function(param, success) {
+        var eventStatus = param.eventStatus, purpose = param.purpose;
+        if (!success) return Promise.resolve();
+        // if we've already user consents or the user is accepting or declining now
+        // we change the state of the GDPR to use in our tracking
+        if (eventStatus === TCF_EVENTS.USER_ACTION_COMPLETE || eventStatus === TCF_EVENTS.LOADED) {
+            var consents = purpose.consents;
+            var gdprStateKey = setGdprStateBy(consents);
+            // if it's a user action, then we will track it
+            if (eventStatus === TCF_EVENTS.USER_ACTION_COMPLETE) {
+                // extract the eventId and gdprPrivacy string to send with the track
+                var analyticsStateKey = gdprStateKey.analytics, advertisingStateKey = gdprStateKey.advertising;
+                var gdprPrivacy = {
+                    analytics: analyticsStateKey,
+                    advertising: advertisingStateKey
+                };
+                // temporary during Didomi migration to avoid fake programmatically generated events where the users doesn't really interact
+                var MIGRATION_DIDOMI_SEGMENT_WRAPPER_FLAG = "didomi-migration";
+                var isDidomiMigration = isClient && window.sessionStorage.getItem(MIGRATION_DIDOMI_SEGMENT_WRAPPER_FLAG);
+                return !isDidomiMigration && trackTcf({
+                    gdprPrivacy: gdprPrivacy
+                });
+            }
+        }
+    });
+}

package/lib/universalId.js

@@ -0,0 +1,48 @@
+import { dispatchEvent } from "@s-ui/js/lib/events/index.js";
+import { createUniversalId } from "./utils/hashEmail.js";
+import { getConfig, isClient, setConfig } from "./config.js";
+var USER_DATA_READY_EVENT = "USER_DATA_READY";
+export var getUniversalIdFromConfig = function() {
+    return getConfig("universalId");
+};
+export var getUniversalId = function() {
+    // 1. Try to get universalId from config
+    var universalId = getUniversalIdFromConfig();
+    if (universalId) {
+        setUniversalIdInitialized();
+        return universalId;
+    }
+    // 2. If not available, then we use the email and hash it
+    var userEmail = getConfig("userEmail");
+    if (userEmail) {
+        universalId = createUniversalId(userEmail);
+        setUniversalId(universalId);
+        setUniversalIdInitialized();
+        return universalId;
+    }
+    // 3. We don't have user email, so we don't have universalId
+    // but we've tried, so we set it as initialized
+    setUniversalIdInitialized();
+};
+export var getUserDataAndNotify = function() {
+    if (!isClient) return;
+    var universalId = getUniversalId();
+    var userEmail = getConfig("userEmail");
+    dispatchEvent({
+        eventName: USER_DATA_READY_EVENT,
+        detail: {
+            universalId: universalId,
+            userEmail: userEmail
+        }
+    });
+    return {
+        universalId: universalId,
+        userEmail: userEmail
+    };
+};
+export var setUniversalIdInitialized = function() {
+    setConfig("universalIdInitialized", true);
+};
+export var setUniversalId = function(universalId) {
+    return setConfig("universalId", universalId);
+};

package/lib/utils/checkAnonymousId.js

@@ -0,0 +1,9 @@
+export var checkAnonymousId = function() {
+    var ref, ref1;
+    var ref2;
+    var SEGMENT_ID_USER_WITHOUT_CONSENTS = (ref2 = (ref = window.__SEGMENT_WRAPPER) == null ? void 0 : ref.SEGMENT_ID_USER_WITHOUT_CONSENTS) != null ? ref2 : "anonymous_user";
+    var anonymousId = window.analytics.user == null ? void 0 : (ref1 = window.analytics.user()) == null ? void 0 : ref1.anonymousId();
+    if (anonymousId === SEGMENT_ID_USER_WITHOUT_CONSENTS) {
+        window.analytics.setAnonymousId(null);
+    }
+};

package/lib/utils/cookies.js

@@ -0,0 +1,50 @@
+import _create_for_of_iterator_helper_loose from "@swc/helpers/src/_create_for_of_iterator_helper_loose.mjs";
+export function readCookie(cookieName) {
+    var re = new RegExp(cookieName + "=([^;]+)");
+    var value = re.exec(document.cookie);
+    return value !== null ? unescape(value[1]) : null;
+}
+var ONE_YEAR = 31536000;
+var DEFAULT_PATH = "/";
+var DEFAULT_SAME_SITE = "Lax";
+export function saveCookie(cookieName, data, param) {
+    var ref = param === void 0 ? {} : param, _maxAge = ref.maxAge, maxAge = _maxAge === void 0 ? ONE_YEAR : _maxAge, _path = ref.path, path = _path === void 0 ? DEFAULT_PATH : _path, _reduceDomain = ref.reduceDomain, reduceDomain = _reduceDomain === void 0 ? true : _reduceDomain, _sameSite = ref.sameSite, sameSite = _sameSite === void 0 ? DEFAULT_SAME_SITE : _sameSite;
+    var domain = reduceDomain ? toCookieDomain() : window.location.hostname;
+    var cookieValue = [
+        cookieName + "=" + data,
+        "domain=" + domain,
+        "path=" + path,
+        "max-age=" + maxAge,
+        "SameSite=" + sameSite
+    ].join(";");
+    document.cookie = cookieValue;
+}
+export function removeCookie(cookieName, param) {
+    var ref = param === void 0 ? {} : param, _path = ref.path, path = _path === void 0 ? DEFAULT_PATH : _path, _reduceDomain = ref.reduceDomain, reduceDomain = _reduceDomain === void 0 ? true : _reduceDomain, _sameSite = ref.sameSite, sameSite = _sameSite === void 0 ? DEFAULT_SAME_SITE : _sameSite;
+    var domain = reduceDomain ? toCookieDomain() : window.location.hostname;
+    document.cookie = cookieName + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=" + path + "; domain=" + domain;
+}
+/**
+ * Reduces the domain to main domain name
+ * Examples:
+ *   - www.mywebpage.es -> .mywebpage.es
+ *   - www.my.newwebpage.net -> .newwebpage.net
+ *   - www.mywebpage.co.uk -> .mywebpage.co.uk
+ *
+ * @param {String} domain
+ * @returns {String} dot + main domain
+ */ var toCookieDomain = function(domain) {
+    if (domain === void 0) domain = window.location.hostname || "";
+    var DOT = ".";
+    var hostDomainParts = domain.split(DOT).reverse();
+    if (hostDomainParts.length === 1) {
+        return hostDomainParts[0];
+    }
+    var cookieDomainParts = [];
+    for(var _iterator = _create_for_of_iterator_helper_loose(hostDomainParts), _step; !(_step = _iterator()).done;){
+        var part = _step.value;
+        cookieDomainParts.push(part);
+        if (part.length > 3) break;
+    }
+    return "" + DOT + cookieDomainParts.reverse().join(DOT);
+};

package/lib/utils/ga4Detection.js

@@ -0,0 +1,18 @@
+import { getConfig } from "../config.js";
+/**
+ * Check if Google Analytics 4 Web destination is enabled in Segment
+ * Simple detection based on googleAnalyticsMeasurementId presence:
+ * - If googleAnalyticsMeasurementId is configured → LEGACY mode (manual GA4)
+ * - If NOT configured → NEW mode (Segment destination handles GA4)
+ * @returns {boolean}
+ */ export var isGA4DestinationEnabled = function() {
+    var googleAnalyticsMeasurementId = getConfig("googleAnalyticsMeasurementId");
+    // If no measurement ID configured, assume they're using Segment destination
+    return !googleAnalyticsMeasurementId;
+};
+/**
+ * Reset the cached detection (useful for testing)
+ * @deprecated No longer needed as detection is now stateless
+ */ export var resetGA4DetectionCache = function() {
+// No-op: detection is now stateless, no cache to reset
+};

package/lib/utils/hashEmail.js

@@ -0,0 +1,24 @@
+import md5 from "tiny-hashes/md5/md5.js";
+import sha256 from "tiny-hashes/sha256/sha256.js";
+var PLUS_AND_DOT = /\.|\+.*$/g;
+/**
+ * Normalize email by lowering case and extracting + and . symbols for gmail
+ * @param {string} email
+ * @return {string} Normalized email. If not valid, returns and empty string
+ */ export function normalizeEmail(email) {
+    if (typeof email !== "string") return "";
+    email = email.toLowerCase();
+    var emailParts = email.split(/@/);
+    if (emailParts.length !== 2) return "";
+    var username = emailParts[0], domain = emailParts[1];
+    username = username.replace(PLUS_AND_DOT, "");
+    return username + "@" + domain;
+}
+export function createUniversalId(email) {
+    var normalizedEmail = normalizeEmail(email);
+    return normalizedEmail ? sha256(normalizedEmail) : "";
+}
+export function hashEmail(email) {
+    var normalizedEmail = normalizeEmail(email);
+    return normalizedEmail ? md5(normalizedEmail) : "";
+}

package/lib/utils/patchAnalytics.js

@@ -0,0 +1,36 @@
+import _extends from "@swc/helpers/src/_extends.mjs";
+import { isClient } from "../config.js";
+import { decorateContextWithNeededData, getDefaultProperties } from "../segmentWrapper.js";
+var MPI_PATCH_FIELD = "__mpi_patch";
+function monkeyPatchAnalyticsTrack() {
+    var _analytics = window.analytics, originalTrack = _analytics.track;
+    window.analytics.track = function() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        var event = args[0], properties = args[1], contextFromArgs = args[2], fn = args[3];
+        var newProperties = _extends({}, getDefaultProperties(), properties);
+        decorateContextWithNeededData({
+            context: contextFromArgs,
+            event: event,
+            properties: newProperties
+        }).then(function(param) {
+            var newContext = param.context, decoratedProperties = param.properties;
+            originalTrack.call(window.analytics, event, decoratedProperties, _extends({}, newContext, {
+                context: {
+                    integrations: _extends({}, newContext.integrations)
+                }
+            }), fn);
+        });
+        return window.analytics;
+    };
+    // add a flag to the patched analytics so we don't patch this twice
+    window.analytics[MPI_PATCH_FIELD] = true;
+}
+if (isClient) {
+    if (!window.analytics) {
+        console.warn("Segment Analytics is not loaded so patch is not applied.");
+    } else if (!window.analytics[MPI_PATCH_FIELD]) {
+        window.analytics.initialized ? monkeyPatchAnalyticsTrack() : window.analytics.ready(monkeyPatchAnalyticsTrack);
+    }
+}

package/lib/utils/storage.js

@@ -0,0 +1,17 @@
+// @ts-check
+/**
+ * Use this module to store and retrieve data from localStorage or sessionStorage
+ * @param {object} params
+ * @param {string} params.key
+ * @param {'getItem'|'removeItem'|'setItem'=} params.method
+ * @param {'localStorage'|'sessionStorage'=} params.type
+ * @param {string=} params.value
+ * @returns {string|void}
+ */ export var storage = function(param) {
+    var _type = param.type, type = _type === void 0 ? "localStorage" : _type, _method = param.method, method = _method === void 0 ? "getItem" : _method, key = param.key, value = param.value;
+    try {
+        return window[type][method](key, value);
+    } catch (e) {
+        console.error(e);
+    }
+};

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@ohos-ports/s-ui-segment-wrapper",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "5.4.0-beta.0",
+  "description": "Abstraction layer on top of the Segment library.",
+  "main": "lib/index.js",
+  "license": "ISC",
+  "scripts": {
+    "lib": "sui-js-compiler",
+    "postlib": "npm run set:version",
+    "prepublishOnly": "npm run umd && npm run lib",
+    "set:version": "sed -i.bak \"s/process\\.env\\.VERSION/\\\"$npm_package_version\\\"/g\" lib/segmentWrapper.js && rm lib/segmentWrapper.js.bak",
+    "test": "npm run test:client",
+    "test:client": "VERSION=0.0.0 sui-test browser --src-pattern=src/index.js -H",
+    "test:client:watch": "VERSION=0.0.0 npm run test:client -- --watch",
+    "test:umd": "npm run umd && npx servor ./umd",
+    "umd": "VERSION=$npm_package_version sui-bundler lib src-umd/index.js -o umd/ -p --root"
+  },
+  "dependencies": {
+    "@s-ui/js": "2",
+    "@swc/helpers": "^0.5.15",
+    "tiny-hashes": "1.0.1"
+  },
+  "devDependencies": {
+    "@s-ui/bundler": "9",
+    "@s-ui/js-compiler": "1",
+    "@s-ui/test": "8"
+  },
+  "config": {
+    "sui-bundler": {
+      "env": [
+        "VERSION"
+      ]
+    }
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/s-ui-segment-wrapper/5.4.0"
+  }
+}

package/src/config.js

@@ -0,0 +1,25 @@
+const MPI_CONFIG_KEY = '__mpi'
+
+export const isClient = typeof window !== 'undefined'
+
+/**
+ * Get the Segment Wrapper config from window
+ * @param {string=} key Key config to extract. If not provided, all the config will be returned
+ * @return {any} Config value or all the config if not key provided
+ */
+export const getConfig = key => {
+  const config = window?.[MPI_CONFIG_KEY]?.segmentWrapper || {}
+
+  return key ? config[key] : config
+}
+
+/**
+ * Set a config value to the Segment Wrapper config
+ * @param {string} key Config key to update
+ * @param {boolean|string|number|object} value Value to set on the config key
+ */
+export const setConfig = (key, value) => {
+  window[MPI_CONFIG_KEY] = window[MPI_CONFIG_KEY] || {}
+  window[MPI_CONFIG_KEY].segmentWrapper = window[MPI_CONFIG_KEY].segmentWrapper || {}
+  window[MPI_CONFIG_KEY].segmentWrapper[key] = value
+}

package/src/events.js

@@ -0,0 +1,3 @@
+export const EVENTS = {
+  GA4_INIT_EVENT_SENT: 'ga4InitEventSent'
+}

package/src/index.js

@@ -0,0 +1,96 @@
+import './utils/patchAnalytics.js'
+
+import {campaignContext} from './middlewares/source/campaignContext.js'
+import {pageData} from './middlewares/source/pageData.js'
+import {defaultContextProperties} from './middlewares/source/defaultContextProperties.js'
+import {pageReferrer} from './middlewares/source/pageReferrer.js'
+import {userScreenInfo} from './middlewares/source/userScreenInfo.js'
+import {userTraits} from './middlewares/source/userTraits.js'
+import {
+  DEFAULT_DATA_LAYER_NAME,
+  getCampaignDetails,
+  loadGoogleAnalytics,
+  sendGoogleConsents
+} from './repositories/googleRepository.js'
+import {checkAnonymousId} from './utils/checkAnonymousId.js'
+import {isGA4DestinationEnabled} from './utils/ga4Detection.js'
+import {getConfig, isClient} from './config.js'
+import analytics from './segmentWrapper.js'
+import initTcfTracking from './tcf.js'
+import {getUserDataAndNotify} from './universalId.js'
+
+// Initialize TCF Tracking with Segment
+initTcfTracking()
+
+// Generate UniversalId if available
+try {
+  getUserDataAndNotify()
+} catch (e) {
+  console.error(`[segment-wrapper] UniversalID couldn't be initialized`) // eslint-disable-line
+}
+
+// Initialize middlewares
+const addMiddlewares = () => {
+  const experimentalPageDataMiddleware = getConfig('experimentalPageDataMiddleware')
+
+  window.analytics.addSourceMiddleware(userTraits)
+  window.analytics.addSourceMiddleware(defaultContextProperties)
+  window.analytics.addSourceMiddleware(campaignContext)
+  window.analytics.addSourceMiddleware(userScreenInfo)
+  window.analytics.addSourceMiddleware(pageReferrer)
+
+  if (experimentalPageDataMiddleware) {
+    window.analytics.addSourceMiddleware(pageData)
+  }
+}
+
+if (isClient && window.analytics) {
+  // Check GA4 mode synchronously to avoid delaying initialization
+  const useSegmentGA4Destination = isGA4DestinationEnabled()
+
+  // Only initialize manual GA4 if destination is not enabled (legacy mode)
+  // This runs synchronously to ensure GA4 is ready for first events
+  if (!useSegmentGA4Destination) {
+    // Legacy behavior: Initialize Google Analytics manually
+    const googleAnalyticsMeasurementId = getConfig('googleAnalyticsMeasurementId')
+    const dataLayerName = getConfig('googleAnalyticsDataLayer') || DEFAULT_DATA_LAYER_NAME
+    const needsConsentManagement = getConfig('googleAnalyticsConsentManagement')
+
+    if (googleAnalyticsMeasurementId) {
+      const googleAnalyticsConfig = getConfig('googleAnalyticsConfig')
+
+      window[dataLayerName] = window[dataLayerName] || []
+      window.gtag =
+        window.gtag ||
+        function gtag() {
+          window[dataLayerName].push(arguments)
+        }
+
+      window.gtag('js', new Date())
+      if (needsConsentManagement) sendGoogleConsents()
+      window.gtag('config', googleAnalyticsMeasurementId, {
+        cookie_prefix: 'segment',
+        send_page_view: false,
+        ...googleAnalyticsConfig,
+        ...getCampaignDetails()
+      })
+      loadGoogleAnalytics().catch(error => {
+        console.error(error)
+      })
+    }
+  }
+
+  window.analytics.ready(checkAnonymousId)
+  window.analytics.addSourceMiddleware ? addMiddlewares() : window.analytics.ready(addMiddlewares)
+}
+
+export default analytics
+export {getGoogleClientId, getGoogleSessionId} from './repositories/googleRepository.js'
+export {getUniversalId} from './universalId.js'
+export {EVENTS} from './events.js'
+
+// Deprecated Adobe Analytics functions - kept for backwards compatibility
+// @deprecated Adobe Analytics integration has been removed
+export const getAdobeVisitorData = () => Promise.resolve({trackingServer: '', version: ''})
+// @deprecated Adobe Analytics integration has been removed
+export const getAdobeMCVisitorID = () => Promise.resolve('')

package/src/middlewares/destination/optimizelySiteAttribute.js

@@ -0,0 +1,22 @@
+export const optimizelySiteAttributeMiddleware = ({payload, next}) => {
+  const {
+    obj: {integrations, context}
+  } = payload
+
+  if (!context.site) {
+    return next(payload)
+  }
+
+  payload.obj.integrations = {
+    ...integrations,
+    Optimizely: {
+      ...integrations.Optimizely,
+      attributes: {
+        site: context.site,
+        ...integrations.Optimizely?.attributes
+      }
+    }
+  }
+
+  next(payload)
+}

package/src/middlewares/source/campaignContext.js

@@ -0,0 +1,12 @@
+import {getCampaignDetails} from '../../repositories/googleRepository.js'
+
+export const campaignContext = ({payload, next}) => {
+  const campaignDetails = getCampaignDetails({needsTransformation: false})
+
+  payload.obj.context = {
+    ...payload.obj.context,
+    ...campaignDetails
+  }
+
+  next(payload)
+}

package/src/middlewares/source/defaultContextProperties.js

@@ -0,0 +1,15 @@
+import {getConfig} from '../../config.js'
+
+const DEFAULT_CONTEXT = {platform: 'web'}
+
+export const defaultContextProperties = ({payload, next}) => {
+  const defaultContext = getConfig('defaultContext') || {}
+
+  payload.obj.context = {
+    ...DEFAULT_CONTEXT,
+    ...defaultContext,
+    ...payload.obj.context
+  }
+
+  next(payload)
+}