@salla.sa/analytics 2.14.548

package/src/shared/host-resolver.js

@@ -0,0 +1,58 @@
+export const FALLBACK_ANALYTICS_HOST = 'https://salla.cloud/_app/e';
+
+/**
+ * Resolve the per-store analytics ingestion host from the store URL.
+ *
+ * - salla.sa stores (https://salla.sa/[ar|en/]store-name) -> origin/store-name/_app/e
+ * - demostore.salla.sa -> origin/store-name/_app/e (falls back when no store name)
+ * - custom domains (incl. multi-part TLDs like co.uk, com.sa) -> origin/_app/e
+ * - inside an iframe the configured host wins (same-origin proxying is impossible)
+ *
+ * @param {string|null} storeUrl the store's public URL
+ * @param {object} [options]
+ * @param {boolean} [options.iframe] running inside an iframe (theme preview)
+ * @param {string|null} [options.iframeHost] host to use when iframe is true
+ * @param {function} [options.log] logger for resolution failures
+ * @returns {string} analytics ingestion endpoint
+ */
+export function resolveAnalyticsHost(storeUrl, { iframe = false, iframeHost = null, log = () => {} } = {}) {
+    if (iframe) {
+        return iframeHost ?? FALLBACK_ANALYTICS_HOST;
+    }
+    if (!storeUrl) {
+        log('Error getting store url - no store URL provided');
+        return FALLBACK_ANALYTICS_HOST;
+    }
+
+    try {
+        // demostore.salla.sa - extract store name and use it
+        if (/https:\/\/demostore\.salla\.sa/.test(storeUrl)) {
+            const demostoreMatch = storeUrl.match(/demostore\.salla\.sa\/(?:(ar|en)\/)?((?!ar$|en$)[a-zA-Z0-9.-]+)/);
+            if (demostoreMatch && demostoreMatch[2]) {
+                const parsed = new URL(storeUrl);
+                return `${parsed.origin}/${demostoreMatch[2]}/_app/e`;
+            }
+            return FALLBACK_ANALYTICS_HOST;
+        }
+
+        // salla.sa domains: https://salla.sa/greenland9 or https://salla.sa/ar/greenland9
+        const sallaPattern = /(salla\.sa)\/(?:(ar|en)\/)?((?!ar$|en$)[a-zA-Z0-9.-]+)/;
+        const sallaMatch = storeUrl.match(sallaPattern);
+
+        if (sallaMatch) {
+            const storeName = sallaMatch[3];
+            if (!storeName || storeName.trim().length === 0 || storeName === 'ar' || storeName === 'en') {
+                log('Error: invalid or empty store name in salla.sa URL');
+                return FALLBACK_ANALYTICS_HOST;
+            }
+            const parsed = new URL(storeUrl);
+            return `${parsed.origin}/${storeName}/_app/e`;
+        }
+
+        const parsed = new URL(storeUrl);
+        return `${parsed.origin}/_app/e`;
+    } catch (error) {
+        log('Error getting store url, forwarding to salla.cloud:', error);
+        return FALLBACK_ANALYTICS_HOST;
+    }
+}

package/src/shared/tracker-registry.js

@@ -0,0 +1,55 @@
+/**
+ * Custom tracker registry shared by the storefront and checkout engines.
+ * A tracker is {name: string, track: fn(eventName, payload), page: fn(payload)}.
+ */
+export function isValidTracker(tracker, existingTrackers, log = () => {}) {
+    if (typeof tracker !== 'object' || tracker === null) {
+        log('tracker most be an object {name:"tracker name", track: callback, page: callback}!');
+        return false;
+    }
+    if (typeof tracker.name !== 'string' || !tracker.name) {
+        log('tracker.name most be a string!');
+        return false;
+    }
+    if (typeof tracker.track !== 'function') {
+        log('tracker.track most be a function!');
+        return false;
+    }
+    if (typeof tracker.page !== 'function') {
+        log('tracker.page most be a function!');
+        return false;
+    }
+    if (existingTrackers.find((t) => t.name === tracker.name)) {
+        log('tracker with the same name already exists!');
+        return false;
+    }
+    return true;
+}
+
+/** Replay already-sent history to a newly registered tracker. */
+export function replayHistory(tracker, history) {
+    history.forEach(event => {
+        if (event.action === 'track') {
+            return tracker.track(event.eventName, event.payload);
+        }
+        if (event.action === 'page') {
+            return tracker.page(event.payload);
+        }
+    });
+}
+
+/** Fan an event out to every tracker; a failing tracker never breaks the others. */
+export function pushEventToTrackers(trackers, action, eventName, payload = {}, log = () => {}) {
+    const args = action === 'page' ? [eventName] : [eventName, payload];
+    return Promise.allSettled(trackers.map(tracker => pushEventToTracker(tracker[action], args)))
+        .then(results => results.filter(result => result.status === 'rejected').map(result => log('Error on customTracker to send ' + action, result)));
+}
+
+function pushEventToTracker(customTrackerCallback, args) {
+    try {
+        const result = customTrackerCallback(...args);
+        return Promise.resolve(result).catch(error => Promise.reject(error));
+    } catch (error) {
+        return Promise.reject(error);
+    }
+}

package/src/shared/uuid.js

@@ -0,0 +1,10 @@
+export function generateSessionId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}

package/src/storefront/basket-gap-product-added.js

@@ -0,0 +1,29 @@
+import { mapProductFields } from './product-fields.js';
+
+export default class BasketGapProductAdded {
+    constructor(details) {
+        this.item = details[0];
+    }
+
+    toSegment() {
+        const { product, position, cartItem, cartId } = this.item;
+        return {
+            event: 'Product Added',
+            properties: {
+                ...mapProductFields(product, position),
+                cart_id: cartId?.toString(),
+                cart_item_id: cartItem?.id?.toString(),
+                variant: cartItem?.variant?.toString() ?? null,
+                coupon: cartItem?.coupon ?? null,
+                quantity: cartItem?.quantity ?? 1,
+                source: 'basket_gap',
+            },
+        };
+    }
+
+    // Identifies basket-gap component emits by their explicit source marker.
+    // Falls through to FbtProductAdded/ProductAdded for other 'Product Added' emits.
+    static shouldSend(details) {
+        return details?.[0]?.source === 'basket_gap';
+    }
+}

package/src/storefront/cart-updated.js

@@ -0,0 +1,41 @@
+export default class CartUpdated {
+    constructor(details) {
+        this.cart = details;
+    }
+
+    toSegment() {
+        return {
+            event: 'Cart Updated',
+            properties: {
+                cart_id: this.cart.id?.toString(),
+                value: this.cart.total,
+                revenue: this.cart.sub_total,
+                tax: this.cart.tax_amount,
+                discount: this.cart.total_discount,
+                shipping: this.cart.real_shipping_cost,
+                currency: Salla.config.currency()?.code,
+                affiliation: Salla.storage.getWithTTL('s-utms')?.['s-utm-source'],
+                products: this.cart.items?.map(item => ({
+                    product_id: item.product_id?.toString(),
+                    name: item.product_name,
+                    price: item.product_price,
+                    category: item.category?.toString(), // not supported
+                    sku: item.product_sku?.toString(),
+                    position: item.position,
+                    url: item.url,
+                    image_url: item.product_image,
+                    brand: item.brand?.toString(),// not supported
+                    currency: Salla.config.currency()?.code,
+                    variant: item.variant?.toString(),//not supported
+                    coupon: this.cart.coupon,
+                    quantity: item.quantity,
+                }))
+            }
+        };
+        
+    }
+
+    static shouldSend(details) {
+        return salla.config.get('page.slug') === 'cart' && !details?.fromLatestFetched;
+    }
+}

package/src/storefront/cart-viewed.js

@@ -0,0 +1,30 @@
+export default class CartViewed {
+    constructor(details) {
+        this.cart = details[0];
+    }
+
+    toSegment() {
+        return {
+            event: 'Cart Viewed',
+            properties: {
+                cart_id: this.cart.cart_id?.toString(),
+                products: this.cart.products.map(product => ({
+                    product_id: product.id?.toString(),
+                    cart_item_id: product.cart_item_id?.toString(),
+                    name: product.name,
+                    price: product.price,
+                    category: product.category,
+                    sku: product.sku,
+                    position: product.position,
+                    url: product.url,
+                    image_url: product.image_url,
+                    brand: product.brand,
+                    currency: Salla.config.currency()?.code,
+                    variant: product.variant,//todo:: now it's the sku id, we need to be string (option Details names) such: Red/L/Circle
+                    coupon: product.coupon,
+                    quantity: product.quantity,
+                }))
+            }
+        };
+    }
+}

package/src/storefront/coupon-applied.js

@@ -0,0 +1,26 @@
+class CouponApplied {
+    constructor(details) {
+        this.transaction = details;
+    }
+
+    getCartId() {
+        if (salla.config.get('page.slug') === 'cart') {
+            return salla.config.get('page.id')?.toString();
+        }
+        return this.transaction?.data?.cart?.id?.toString() || '';
+    }
+
+    toSegment() {
+        return {
+            event: 'Coupon Applied',
+            properties: {
+                cart_id: this.getCartId(),
+                coupon_name: this.transaction?.data?.cart?.coupon || '',
+                discount: this.transaction?.data?.cart?.discount || 0,
+                currency: salla.config.get('user.currency') || ''
+            }
+        };
+    }
+}
+
+export default CouponApplied;

package/src/storefront/coupon-denied.js

@@ -0,0 +1,35 @@
+
+class CouponDenied {
+    constructor(details) {
+        this.transaction = details;
+    }
+
+    getCartId() {
+        if (salla.config.get('page.slug') === 'cart') {
+            return salla.config.get('page.id')?.toString();
+        }
+        return '';
+    }
+
+    getCouponCode() {
+        try {
+            const data = this.transaction.response?.config?.data;
+            return data ? JSON.parse(data)?.coupon : '';
+        } catch {
+            return '';
+        }
+    }
+
+    toSegment() {
+        return {
+            event: 'Coupon Denied',
+            properties: {
+                cart_id: this.getCartId(),
+                coupon_name: this.getCouponCode(),
+                reason: this.transaction.response?.data?.error?.message || 'Unknown error'
+            }
+        };
+    }
+}
+
+export default CouponDenied;

package/src/storefront/coupon-removed.js

@@ -0,0 +1,27 @@
+
+class CouponRemoved {
+    constructor(details) {
+        this.transaction = details;
+    }
+
+    getCartId() {
+        if (salla.config.get('page.slug') === 'cart') {
+            return salla.config.get('page.id')?.toString();
+        }
+        return this.transaction?.data?.cart?.id?.toString() || '';
+    }
+
+    toSegment() {
+        return {
+            event: 'Coupon Removed',
+            properties: {
+                cart_id: this.getCartId(),
+                coupon_name: this.transaction?.coupon || '',
+                discount: this.transaction?.data?.cart?.discount || 0,
+                currency: salla.config.get('user.currency') || ''
+            }
+        };
+    }
+}
+
+export default CouponRemoved; 

package/src/storefront/event-transformer.js

@@ -0,0 +1,90 @@
+import ProductAdded from './product-added';
+import RecommendationListViewed from './recommendation-list-viewed';
+import ProductClicked from './product-clicked';
+import FbtProductAdded from './fbt-product-added';
+import BasketGapProductAdded from './basket-gap-product-added';
+import ProductViewed from './product-viewed';
+import CartViewed from './cart-viewed';
+import ProductListViewed from './product-list-viewed';
+import ProductsSearched from './products-searched';
+import SignedUp from './signed-up';
+import SignedIn from './signed-in';
+import SignedOut from './signed-out';
+import ProductRemoved from './product-removed';
+import ProductAddedToWishlist from './product-added-to-wishlist';
+import ProductRemovedFromWishlist from './product-removed-from-wishlist';
+import OrderCompleted from './order-completed';
+import WishlistProductAddedToCart from './wishlist-product-added-to-cart';
+import ProductShared from './product-shared';
+import ProductReviewed from './product-reviewed';
+import PromotionViewed from './promotion-viewed';
+import PromotionClicked from './promotion-clicked';
+import CouponApplied from './coupon-applied';
+import CouponDenied from './coupon-denied';
+import CouponRemoved from './coupon-removed';
+import UserProfileUpdated from './user-profile-updated';
+import ProductListFiltered from './product-list-filtered';
+import CartUpdated from './cart-updated';
+import MarketSelected from './market-selected';
+import ProductReordered from './product-reordered';
+
+export default class EventTransformer {
+  static events = {
+    'Order Completed': [OrderCompleted],
+    'Product Added': [BasketGapProductAdded, FbtProductAdded, ProductAdded, WishlistProductAddedToCart],
+    'Product Removed': [ProductRemoved],
+    'Product Viewed': [ProductViewed],
+    'Product Added to Wishlist': [ProductAddedToWishlist],
+    'Product Removed from Wishlist': [ProductRemovedFromWishlist],
+    'Cart Viewed': [CartViewed],
+    'Products Searched': [ProductsSearched],
+    'Product List Viewed': [ProductListViewed],
+    'Product List Filtered': [ProductListFiltered],
+    'Signed Up': [SignedUp],
+    'Signed In': [SignedIn],
+    'Signed Out': [SignedOut],
+    'Product Reviewed': [ProductReviewed],
+    'Product Shared': [ProductShared],
+    'Promotion Viewed': [PromotionViewed],
+    'Promotion Clicked': [PromotionClicked],
+    'Coupon Applied': [CouponApplied],
+    'Coupon Removed': [CouponRemoved],
+    'Coupon Denied': [CouponDenied],
+    'User Profile Updated': [UserProfileUpdated],
+    'Cart Updated': [CartUpdated],
+    'Market Selected': [MarketSelected],
+    'Product Reordered': [ProductReordered],
+    'Recommendation List Viewed': [RecommendationListViewed],
+    'Product Clicked': [ProductClicked],
+  };
+
+  static registerEvents() {
+    Object.values(this.events).forEach(eventHandlers => {
+      eventHandlers.forEach(eventClass => {
+        if (typeof eventClass.registerEvent === 'function') {
+          eventClass.registerEvent();
+        }
+      });
+    });
+  }
+
+  static transform(eventName, details) {
+    try {
+            // Get the array of event handlers for this event name
+      const eventHandlers = this.events[eventName] || [];
+      for (const eventClass of eventHandlers) {
+        if (!eventClass || 
+            (typeof eventClass.shouldSend === 'function' && !eventClass.shouldSend(details))) {
+          continue;
+        }
+        const result = new eventClass(details).toSegment();
+        return { event: result.event, properties: result.properties };
+      }
+
+      return null;
+    } catch (error) {
+      console.error('Failed to transform event:', error);
+      return null;
+    }
+  }
+}

package/src/storefront/fbt-product-added.js

@@ -0,0 +1,29 @@
+import { mapProductFields } from './product-fields.js';
+
+export default class FbtProductAdded {
+    constructor(details) {
+        this.item = details[0];
+    }
+
+    toSegment() {
+        const { product, position, cartItem, cartId } = this.item;
+        return {
+            event: 'Product Added',
+            properties: {
+                ...mapProductFields(product, position),
+                cart_id: cartId?.toString(),
+                cart_item_id: cartItem?.id?.toString(),
+                variant: cartItem?.variant?.toString() ?? null,
+                coupon: cartItem?.coupon ?? null,
+                quantity: cartItem?.quantity ?? 1,
+                source: 'pdp_fbt',
+            },
+        };
+    }
+
+    // Identifies FBT component emits by their { product, position, cartItem, cartId } shape.
+    // Cart auto-track emits a flat product object — no .product key — so it falls through to ProductAdded.
+    static shouldSend(details) {
+        return !!details?.[0]?.product;
+    }
+}