@salla.sa/analytics 2.14.548

package/src/storefront/index.js

@@ -0,0 +1,524 @@
+import { jitsuAnalytics, windowRuntime } from '@jitsu/js';
+import EventTransformer from './event-transformer.js';
+import { resolveAnalyticsHost } from '../shared/host-resolver.js';
+import { captureSallaCookies } from '../shared/cookie-capture.js';
+import { isValidTracker, replayHistory, pushEventToTrackers } from '../shared/tracker-registry.js';
+import { applyExtraContext } from '../shared/extra-context.js';
+import { generateSessionId } from '../shared/uuid.js';
+
+const SESSION_STORAGE_KEY = 's-session-id';
+const SESSION_TTL_MINUTES = 30;
+
+export default class Analytics {
+    constructor() {
+        this.history = [];
+        this.customTrackers = [];
+        this.context = {};
+        this._anonymousId = null;
+        this._sessionId = null;
+        this._jitsuConfig = null;
+        this.mappedEvents = {
+            'wishlist::added': 'Product Added to Wishlist',
+            'wishlist::removed': 'Product Removed from Wishlist',
+            'salla-products-list::products.fetched': ['Product List Viewed', 'Product List Filtered'],
+            'auth::registered': 'Signed Up',
+            'auth::logged.in': 'Signed In', 
+            'auth::logged.out': 'Signed Out',
+            'share-element': 'Product Shared',
+            'promotion::viewed': 'Promotion Viewed',
+            'promotion::clicked': 'Promotion Clicked',
+            'salla::offer.promotion.viewed': 'Promotion Viewed',
+            'salla::offer.promotion.clicked': 'Promotion Clicked',
+            'cart::coupon.added': 'Coupon Applied',
+            'cart::coupon.deleted': 'Coupon Removed',
+            'cart::coupon.addition.failed': 'Coupon Denied',
+            'profile::updated' : 'User Profile Updated',
+            'cart::updated' : 'Cart Updated',
+            'scope::changed' : 'Market Selected',
+            'order::order.created': 'Product Reordered',
+            'salla-bought-together::list.viewed':     'Recommendation List Viewed',
+            'salla-bought-together::product.clicked': 'Product Clicked',
+            'salla-bought-together::product.added':   'Product Added',
+            'salla-basket-gap::product.added':        'Product Added',
+        };
+        Salla.event.onAny((event, details) => {
+            try {
+                if (Object.keys(this.mappedEvents).includes(event)) {
+                    const mapped = this.mappedEvents[event];
+                    const targets = Array.isArray(mapped) ? mapped : [mapped];
+                    targets.forEach((mappedEventKey) => Salla.event.emit(mappedEventKey, details));
+                    return;
+                }
+
+                if (!Salla.config.get('jitsu.events', []).includes(event)) {
+                    return;
+                }
+
+                const segmentEvent = EventTransformer.transform(event, details);
+                if (segmentEvent) {
+                    this.track(segmentEvent.event, segmentEvent.properties);
+                }
+            } catch (error) {
+                Salla.log('Error in analytics event handling:', error);
+            }
+        });
+
+        Salla.event.on('salla-cookies-bar::accepted', () => this.setConsent('accepted'));
+        Salla.event.on('salla-cookies-bar::rejected', () => this.setConsent('rejected'));
+        Salla.event.on('auth::logged.out', () => this.clearSessionId());
+
+        Salla.event.on('twilight::before.ready', (config) => {
+            this.debugAnalytics = jitsuAnalytics({
+                host: 'https://st.salla.dev',
+                writeKey: 'bbLD6Xqr1OKsDJfxZBCy7SJN1RIsrkBp:WEa99iY220v9qX7KiuAlML9ldSFJKW2p'
+            });
+            const { host, key: writeKey } = config?.jitsu || {};
+            this.jitsuAnalytics = null;
+            if (!host || !writeKey) {
+                salla.log('Jitsu configuration is missing. Analytics will not be tracked.');
+                return;
+            }
+            EventTransformer.registerEvents();
+            this._jitsuConfig = {
+                host: this.getAnalyticsHost(config),
+                writeKey,
+                cookieCapture: captureSallaCookies(),
+                runtime: this.getSafeJitsuRuntime(config),
+                ...(Salla.helpers.isIframe() && { fetch: (url, options) => this.customFetch(url, options) }),
+            };
+            const consentPolicies = this.getConsentPolicies();
+            this.jitsuAnalytics = jitsuAnalytics({
+                ...this._jitsuConfig,
+                ...consentPolicies,
+            });
+            
+            config.jitsu.anonymous_id && this.jitsuAnalytics.setAnonymousId(config.jitsu.anonymous_id);
+            // Initialize and cache anonymous ID immediately after Jitsu is created
+            this._anonymousId = this.jitsuAnalytics?.user()?.anonymousId || null;
+
+            config.jitsu.session_id && this.setContext('session_id', config.jitsu.session_id);
+            // Initialize and cache anonymous ID immediately after Jitsu is created
+            this._sessionId = this.jitsuAnalytics?.getContextProperty('session_id');
+
+            this.setContext('store_id', config.store?.id);
+            this.setContext('version', config.jitsu?.version);
+            this.setContext('library',{twilight:Salla.versions});
+            this.setContext('theme',{
+                name: String(Salla.config.get('theme.name')),
+                version: String(Salla.config.get('headers.s-version-id'))
+            });
+            if(config.jitsu?.context?.extra){
+                this.setExtraContext(config.jitsu.context.extra);
+            }
+
+            if (config.store?.scope?.id) {
+                // this.jitsuAnalytics.setContextProperty('scope', config.store?.scope);
+                this.setContext('scope', config.store?.scope);
+            }
+            if (config?.user?.type === 'user') {
+                this.setContext('traits', this.getFormattedUser(config.user));
+            }
+
+            // Register default Salla tracker
+            this.registerTracker({
+                name: 'DefaultSallaTracker',
+                track: (eventName, payload) => this.jitsuAnalytics.track(eventName, payload),
+                page: (payload) => this.jitsuAnalytics.page(payload),
+            });
+        });
+
+        Salla.onReady(() => {
+            this.initSessionId();
+            const pagePayload = { name: Salla.config.get('page.slug', ''), id:Salla.config.get('page.id', '')?.toString()};
+            this.setContext('page', pagePayload);
+            this.attachViewedSource();
+            Salla.config.set('jitsu.anonymous_id', this._anonymousId);
+            Salla.config.set('jitsu.session_id', this._sessionId);
+            this.page(pagePayload);
+        });
+    }
+
+    attachViewedSource() {
+        try {
+            const url = new URL(window.location.href);
+            const value = url.searchParams.get('_svs');
+            if (!value) return;
+            url.searchParams.delete('_svs');
+            window.history.replaceState(window.history.state, '', url.toString());
+            const sanitized = value.replace(/[^\p{L}\p{N}\-_ ]/gu, '').trim().slice(0, 100);
+            if (!sanitized) return;
+            this.setContext('viewed_source', sanitized);
+        } catch (error) {
+            Salla.log('Error reading viewed_source from URL:', error);
+        }
+    }
+
+    setExtraContext(extra){
+        applyExtraContext((key, value) => this.setContext(key, value), extra, (...args) => Salla.log(...args));
+    }
+
+    getAnalyticsHost(config) {
+        return resolveAnalyticsHost(config?.store?.url, {
+            iframe: Salla.helpers.isIframe(),
+            iframeHost: config?.jitsu?.host,
+            log: (...args) => Salla.log(...args),
+        });
+    }
+
+    setContext(key, value){
+      this.jitsuAnalytics?.setContextProperty(key, value);
+      this.debugAnalytics?.setContextProperty(key, value);
+      this.context[key] = value;
+    }
+
+    /**
+     * Set app-specific context for partner applications
+     * @param {string} appId - The unique identifier for the partner app (e.g., 'webengage')
+     * @param {object} payload - The context data to store for this app
+     */
+    setAppContext(appId, payload) {
+      if (!this.jitsuAnalytics) {
+        Salla.log('setAppContext: Analytics not initialized yet');
+        return;
+      }
+
+      if (!appId || typeof appId !== 'string') {
+        Salla.log('setAppContext: appId must be a non-empty string');
+        return;
+      }
+
+      if (!payload || typeof payload !== 'object') {
+        Salla.log('setAppContext: payload must be an object');
+        return;
+      }
+
+      const currentAppsContext = this.context.apps_context || {};
+      currentAppsContext[appId] = {
+        ...currentAppsContext[appId],
+        ...payload
+      };
+
+      this.setContext('apps_context', currentAppsContext);
+    }
+
+    /**
+     * Execute a callback with scoped app context. All track() calls within
+     * the callback will include the scoped context in payload.context.
+     * Supports both sync and async callbacks; for async callbacks,
+     * apps_context stays populated until the returned promise settles.
+     * @param {string} appId - The app identifier
+     * @param {function} callback - Receives a scope object with setContext(key, value)
+     * @returns {*} The callback's return value (a Promise if the callback is async)
+     */
+    withAppScope(appId, callback) {
+        if (!appId || typeof appId !== 'string') {
+            Salla.log('withAppScope: appId must be a non-empty string');
+            return;
+        }
+        if (typeof callback !== 'function') {
+            Salla.log('withAppScope: callback must be a function');
+            return;
+        }
+
+        // Snapshot only this scope's entry against the live apps_context,
+        // so overlapping scopes for *other* appIds aren't clobbered when we
+        // restore. The live apps_context is re-read inside restore().
+        const hadAppEntry = this.context.apps_context != null
+            && Object.prototype.hasOwnProperty.call(this.context.apps_context, appId);
+        const previousAppEntry = hadAppEntry ? this.context.apps_context[appId] : undefined;
+
+        const self = this;
+        const scope = {
+            appId,
+            setContext(key, value) {
+                self.setAppContext(appId, { [key]: value });
+            }
+        };
+
+        // Seed the entry so the appId is present in apps_context even
+        // if the callback never calls scope.setContext.
+        self.setAppContext(appId, {});
+
+        // Cleanup via macrotask so Jitsu's async plugin processing
+        // (microtask/Promise-based) reads the scoped context before we clear it
+        const restore = () => setTimeout(() => {
+            const current = self.context.apps_context
+                ? { ...self.context.apps_context }
+                : {};
+            if (hadAppEntry) {
+                current[appId] = previousAppEntry;
+            } else {
+                delete current[appId];
+            }
+            self.setContext(
+                'apps_context',
+                Object.keys(current).length ? current : undefined,
+            );
+        }, 0);
+
+        let result;
+        try {
+            result = callback(scope);
+        } catch (err) {
+            restore();
+            throw err;
+        }
+
+        if (result && typeof result.then === 'function') {
+            // Promise.resolve normalizes any thenable (including ones without
+            // .finally) into a real Promise so cleanup is guaranteed.
+            return Promise.resolve(result).finally(restore);
+        }
+        restore();
+        return result;
+    }
+
+    // Use normal fetch with keepalive instead of beacon, as beacon is mostly blocked by ad blockers.
+    // keepalive ensures the request completes even if the page reloads or navigates away.
+    customFetch(url, options) {
+        return fetch(url, { ...options, keepalive: true });
+    }
+
+    getSafeJitsuRuntime(config = {}) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+
+        const runtime = windowRuntime(config);
+
+        return {
+            ...runtime,
+            pageUrl: () => this.normalizeUrlForDecodeURIComponent(runtime.pageUrl()),
+        };
+    }
+
+    normalizeUrlForDecodeURIComponent(url) {
+        try {
+            const parsedUrl = new URL(url);
+
+            if (parsedUrl.search) {
+                parsedUrl.search = new URLSearchParams(parsedUrl.search).toString();
+            }
+
+            return parsedUrl.toString();
+        } catch (error) {
+            Salla.log('Error normalizing analytics page URL:', error);
+            return url;
+        }
+    }
+
+    track(eventName, payload = {}) {
+        this.refreshSessionIdTTL();
+        payload = this.finalPayload(payload);
+        this.history.push({ action: 'track', eventName, payload });
+        this.pushEventToCustomTrackers('track', eventName, payload);
+    }
+
+    log(eventName, payload = {}) {
+        return this.debugAnalytics?.track(eventName, payload).catch((error) => {
+            Salla.log("Error tracking event:", error);
+            return Promise.reject(error);
+        });
+    }
+
+    page(payload = {}) {
+        this.refreshSessionIdTTL();
+        payload = this.finalPayload(payload);
+        payload.id = (payload.id || Salla.config.get('page.id', ''))?.toString();
+        payload.name = payload.name || Salla.config.get('page.slug');
+        payload.keywords = payload.keywords || document.querySelector('meta[name=keywords]')?.content;
+        payload.referrer = payload.referrer || document.referrer;
+
+        this.history.push({ action: 'page', payload });
+        this.pushEventToCustomTrackers('page', payload);
+    }
+
+    finalPayload(payload = {}) {
+        let defaultPayload = {};
+        this.attachRealtimeContext();
+        payload.event_id = payload.event_id || this.generateId();
+
+        return {
+            ...defaultPayload,
+            ...payload
+        };
+    }
+
+    attachRealtimeContext() {
+        try {
+            const hasCookiesConsent = Salla.storage.get('cookies-consent') === 'accepted';
+            const sensitiveKeys = ['user.id', 'cart.user_id'];
+            const keys = ['user.id', 'cart.id', 'cart.user_id', 'cart.count', 'cart.summary.count', 'scope.id', 'branch-choosed-before']
+                .filter((key) => hasCookiesConsent || !sensitiveKeys.includes(key));
+            const storageData = keys.reduce((acc, key) => {
+                const value = Salla.storage.get(key);
+                if (value) {
+                    acc[key.replace('.', '_')] = value;
+                }
+                return acc;
+            }, {});
+
+            if (!hasCookiesConsent) {
+                // Ensure sensitive IDs are removed even if an old context existed.
+                delete storageData.user_id;
+                delete storageData.cart_user_id;
+            }
+
+            this.setContext('localStorage', Object.keys(storageData).length > 0 ? storageData : undefined);
+
+            //This keys should be added only inside web view to unify the experience between native and webview
+            ['device', 'os', 'app'].forEach((key) => {
+                const value = Salla.storage.get(key);
+                if (value) {
+                    this.setContext(key, value);
+                }
+            });
+        } catch (error) {
+            Salla.analytics.log('attachRealtimeContext', {error: error.message});
+            Salla.log('Error attaching realtime context:', error);
+        }
+
+        const utms = Salla.storage.getWithTTL('s-utms');
+        if (!utms) {
+            return;
+        }
+        const {
+            's-utm-campaign': name,
+            's-utm-source': source,
+            's-utm-medium': medium,
+            's-utm-term': term,
+            's-utm-content': content,
+            's-utm-referrer': referrer
+        } = utms;
+
+        this.setContext('campaign', {
+            name,
+            source,
+            medium,
+            term,
+            content,
+            referrer
+        });
+    }
+
+    registerTracker(tracker) {
+        if (!isValidTracker(tracker, this.customTrackers, (...args) => Salla.log(...args))) {
+            return;
+        }
+        this.customTrackers.push(tracker);
+        replayHistory(tracker, this.history);
+    }
+
+    pushEventToCustomTrackers(action, eventName, payload = {}) {
+        return pushEventToTrackers(this.customTrackers, action, eventName, payload, (...args) => Salla.log(...args));
+    }
+
+    getConsentState() {
+        return Salla.storage.get('cookies-consent', 'unknown');
+    }
+
+    getConsentPolicies(state = null) {
+        if (!Salla.config.get('store.features')?.includes('website-cookies')) return {};
+        state = state || this.getConsentState();
+        const isAccepted = state === 'accepted';
+        return {
+            privacy: {
+                dontSend: false,
+                disableUserIds: !isAccepted,
+                ipPolicy: isAccepted ? 'keep' : 'remove',
+            },
+        };
+    }
+
+    setConsent(state) {
+        if (!Salla.config.get('store.features')?.includes('website-cookies')) return;
+        if (!['accepted', 'rejected'].includes(state)) return;
+
+        const previousState = this.getConsentState();
+
+        if (!this._jitsuConfig || !this.jitsuAnalytics) return;
+        if (previousState === state) return;
+
+        try {
+            const consentPolicies = this.getConsentPolicies(state);
+            this.jitsuAnalytics = jitsuAnalytics({
+                ...this._jitsuConfig,
+                ...consentPolicies,
+            });
+            this._anonymousId = this.jitsuAnalytics?.user()?.anonymousId || null;
+            Salla.config.set('jitsu.anonymous_id', this._anonymousId);
+
+            // Re-apply stored context, no need to skip traits because it will not sent due to disableUserIds option
+            Object.entries(this.context).forEach(([key, value]) => {
+                this.jitsuAnalytics.setContextProperty(key, value);
+            });
+        } catch (error) {
+            Salla.log('Error re-initializing Jitsu on consent change:', error);
+        }
+    }
+
+    getFormattedUser(user) {
+        user.phone = user.mobile;
+        user.country = user.country_code;
+        user.language = user.language_code;
+        user.currency = user.currency_code;
+        return user;
+    }
+
+    generateId() {
+        return generateSessionId();
+    }
+
+    generateSessionId() {
+        return this.generateId();
+    }
+
+    initSessionId() {
+        this._sessionId = this._sessionId || Salla.storage.getWithTTL(SESSION_STORAGE_KEY) || this.generateSessionId();
+        Salla.storage.setWithTTL(SESSION_STORAGE_KEY, this._sessionId, SESSION_TTL_MINUTES);
+        this.setContext('session_id', this._sessionId);
+    }
+
+    // Sliding 30m inactivity: refresh TTL on track/page; mint new id if storage expired
+    refreshSessionIdTTL() {
+        const stored = Salla.storage.getWithTTL(SESSION_STORAGE_KEY);
+        if (!stored) {
+            this._sessionId = null;
+            this.initSessionId();
+            return;
+        }
+        this._sessionId = stored;
+        Salla.storage.setWithTTL(SESSION_STORAGE_KEY, this._sessionId, SESSION_TTL_MINUTES);
+        this.setContext('session_id', this._sessionId);
+    }
+
+    clearSessionId() {
+        this._sessionId = null;
+        Salla.storage.setWithTTL(SESSION_STORAGE_KEY, null, 0);
+        this.setContext('session_id', null);
+    }
+
+    getAnonymousId() {
+        try {
+            // Return cached anonymous ID if available
+            if (this._anonymousId) {
+                return this._anonymousId;
+            }
+            
+            // Try to get from Jitsu if initialized
+            if (this.jitsuAnalytics) {
+                const anonymousId = this.jitsuAnalytics.user()?.anonymousId;
+                if (anonymousId) {
+                    // Cache it for future use
+                    this._anonymousId = anonymousId;
+                    return anonymousId;
+                }
+            }
+            
+            return null;
+        } catch (error) {
+            Salla.log('Error getting anonymous ID from Jitsu:', error);
+            return null;
+        }
+    }
+}

package/src/storefront/market-selected.js

@@ -0,0 +1,29 @@
+export default class MarketSelected {
+    constructor(details) {
+        this.scope = details.data;
+    }
+
+    toSegment() {
+        return {
+            event: 'Market Selected',
+            properties: {
+                ...this.getScope(this.scope),
+                prev: this.getScope(Salla.config.get('store.scope')),
+            }
+        };
+    }
+
+    getScope(scope) {
+        scope = scope || {};
+        return {
+            id: scope.id?.toString(),
+            country: this.getScopeAttribute(scope, 'countries'),
+            currency: this.getScopeAttribute(scope, 'currencies'),
+            locale: this.getScopeAttribute(scope, 'languages'),
+        };
+    }
+    getScopeAttribute(scope, key) {
+        scope = scope[key];
+        return Array.isArray(scope) ? scope[0] : scope;
+    }
+}

package/src/storefront/order-completed.js

@@ -0,0 +1,12 @@
+export default class OrderCompleted {
+    constructor(details) {
+        this.details = details[0];
+    }
+
+    toSegment() {
+        return {
+            event: 'Order Completed',
+            properties: this.details
+        };
+    }
+}

package/src/storefront/product-added-to-wishlist.js

@@ -0,0 +1,28 @@
+export default class ProductAddedToWishlist {
+    constructor(details) {
+        this.product = details.data.product;
+    }
+
+    toSegment() {
+        return {
+            event: 'Product Added to Wishlist',
+            properties: {
+                wishlist_id : salla.config.get('store.id') + '_' + salla.config.get('user.id'),
+                wishlist_name : salla.config.get('store.name'),
+                product_id : this.product.id?.toString(),
+                name: this.product.name,
+                brand: this.product.brand,
+                variant: this.product.variant,
+                price: this.product.price,
+                quantity: Math.max(1, Number(this.product.quantity)),
+                sku: this.product.sku || null,
+                position: Number(this.product.position || 0),
+                url: this.product.url,
+                image_url: this.product?.image || null,
+                category: this.product.category,
+                currency: Salla.config.currency()?.code,
+                brand: this.product.brand,
+            }
+        };
+    }
+}

package/src/storefront/product-added.js

@@ -0,0 +1,51 @@
+export default class ProductAdded {
+    constructor(details) {
+        this.item = details[0];
+        this.source = Salla.cart?.api?.addToCartSource || null;
+        if (Salla.cart?.api) Salla.cart.api.addToCartSource = null;
+        // Read the clicked list position from session storage (same passing logic as
+        // s-viewed-source), falling back to any position carried on the item itself.
+        try {
+            const position = sessionStorage.getItem('s-viewed-position');
+            this.position = position !== null ? Number(position) : (this.item.position ?? null);
+            sessionStorage.removeItem('s-viewed-position');
+        } catch {
+            this.position = this.item.position ?? null;
+        }
+    }
+
+    toSegment() {
+        return {
+            event: 'Product Added',
+            properties: {
+                cart_id: this.item.cart_id?.toString(),
+                cart_item_id: this.item.cart_item_id?.toString(),
+                product_id: this.item.id?.toString(),
+                category: this.item.category,
+                currency: Salla.config.currency()?.code,
+                name: this.item.name,
+                brand: this.item.brand,
+                variant: this.item.variant?.toString(),
+                price: this.item.price,
+                quantity: this.item.quantity,
+                sku: this.item.sku,
+                coupon: this.item.coupon,
+                position: this.position,
+                url: this.item.url,
+                image_url: this.item.image_url,
+                source: this.source
+            }
+        };
+    }
+
+    static shouldSend(details) {
+        if (salla.config.get('page.slug') === 'customer.wishlist') return false;
+        // Suppress cart auto-track for component-attributed adds (pdp_fbt / basket_gap) —
+        // FbtProductAdded / BasketGapProductAdded emit those events with their own source.
+        if (['pdp_fbt', 'basket_gap'].includes(Salla.cart?.api?.addToCartSource)) {
+            if (Salla.cart?.api) Salla.cart.api.addToCartSource = null;
+            return false;
+        }
+        return true;
+    }
+}

package/src/storefront/product-clicked.js

@@ -0,0 +1,22 @@
+import { mapProductFields } from './product-fields.js';
+
+export default class ProductClicked {
+    constructor(details) {
+        this.item = details[0];
+    }
+
+    static shouldSend(details) {
+        return !!details?.[0]?.product && !!details?.[0]?.position;
+    }
+
+    toSegment() {
+        const { product, position } = this.item;
+        return {
+            event: 'Product Clicked',
+            properties: {
+                ...mapProductFields(product, position),
+                source: 'pdp_fbt',
+            },
+        };
+    }
+}

package/src/storefront/product-fields.js

@@ -0,0 +1,15 @@
+// Shared field mapping for FBT analytics classes.
+export function mapProductFields(product, position, currency = Salla.config.currency()?.code) {
+    return {
+        product_id: product.id?.toString(),
+        name: product.name,
+        price: product.price,
+        position,
+        url: product.url,
+        image_url: product.image?.url,
+        currency,
+        category: product.category,
+        brand: product.brand?.name ?? product.brand,
+        sku: product.sku,
+    };
+}