@blotoutio/providers-blotout-popup-sdk 1.70.2

package/stores/shopify/index.mjs

@@ -0,0 +1,228 @@
+const BLOTOUT_POPUP_KEY_PREFIX = 'blotoutPopup:';
+const clearKeysWithPrefix = (storage) => {
+    if (!storage) {
+        return;
+    }
+    const toRemove = [];
+    for (let i = 0; i < storage.length; i++) {
+        const key = storage.key(i);
+        if (key && key.startsWith(BLOTOUT_POPUP_KEY_PREFIX)) {
+            toRemove.push(key);
+        }
+    }
+    for (const key of toRemove) {
+        storage.removeItem(key);
+    }
+};
+const clearBlotoutPopupState = () => {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    try {
+        clearKeysWithPrefix(window.sessionStorage);
+    }
+    catch {
+        // ignore — sandboxed / private-mode access throws
+    }
+    try {
+        clearKeysWithPrefix(window.localStorage);
+    }
+    catch {
+        // ignore
+    }
+};
+
+var _a$1;
+const registryKey = Symbol.for('blotout-popup');
+if (typeof window !== 'undefined') {
+    (_a$1 = window[registryKey]) !== null && _a$1 !== void 0 ? _a$1 : (window[registryKey] = {});
+    window[registryKey].clearState = clearBlotoutPopupState;
+}
+
+const canLog = () => {
+    try {
+        return localStorage.getItem('edgeTagDebug') === '1';
+    }
+    catch {
+        return false;
+    }
+};
+const prefix = `[EdgeTag]`;
+const logger = {
+    log: (...args) => {
+        if (canLog()) {
+            console.log(prefix, ...args);
+        }
+    },
+    error: (...args) => {
+        if (canLog()) {
+            console.error(prefix, ...args);
+        }
+    },
+    info: (...args) => {
+        if (canLog()) {
+            console.info(prefix, ...args);
+        }
+    },
+    trace: (...args) => {
+        if (canLog()) {
+            console.trace(prefix, ...args);
+        }
+    },
+};
+
+/**
+ * Themes that announce cart changes do it with one of these. There is no
+ * standard event, and nothing in this repo proves any given theme emits one, so
+ * these are a latency optimisation on top of the poll below — never the only
+ * way a mutation is noticed.
+ */
+const THEME_CART_EVENTS = [
+    'cart:refresh',
+    'cart:change',
+    'cart:updated',
+    'cart-updated',
+    'shopify:cart:updated',
+    'ajaxify:updated',
+];
+// Long enough to be invisible in request logs, short enough that "added to
+// cart" still feels immediate. Only runs while the tab is visible.
+const POLL_MS = 5000;
+// Shopify prices are integer cents.
+const CENTS_PER_UNIT = 100;
+// A stalled request would otherwise hold the tracker's single in-flight slot
+// forever, and every later read — every theme event, every poll — would be
+// coalesced into a re-run that never comes.
+const READ_TIMEOUT_MS = 3000;
+/**
+ * `window.Shopify.routes.root` is a page global, so any other script on the
+ * storefront can set it. Resolving it against the page's own origin and
+ * refusing anything that leaves that origin is what stops a marketing app or a
+ * compromised third-party tag pointing the cart read at a host of its choosing
+ * — which would both beacon every shopper to it and let it dictate
+ * `cart.totalValue`, forcing a discount popup on every visitor.
+ */
+const cartUrl = () => {
+    var _a, _b, _c;
+    const root = (_c = (_b = (_a = window.Shopify) === null || _a === void 0 ? void 0 : _a.routes) === null || _b === void 0 ? void 0 : _b.root) !== null && _c !== void 0 ? _c : '/';
+    try {
+        const url = new URL(`${root}cart.js`, window.location.origin);
+        return url.origin === window.location.origin ? url.href : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+// AbortSignal.timeout is Safari 16 / Chrome 103; older browsers get no timeout
+// rather than a broken read.
+const readSignal = () => typeof AbortSignal !== 'undefined' && 'timeout' in AbortSignal
+    ? AbortSignal.timeout(READ_TIMEOUT_MS)
+    : undefined;
+const toSnapshot = (raw) => {
+    if (typeof raw !== 'object' || raw === null) {
+        return undefined;
+    }
+    const cart = raw;
+    if (typeof cart['item_count'] !== 'number') {
+        return undefined;
+    }
+    const totalCents = typeof cart['total_price'] === 'number' ? cart['total_price'] : 0;
+    return {
+        itemCount: cart['item_count'],
+        totalValue: totalCents / CENTS_PER_UNIT,
+    };
+};
+const shopifyCartAdapter = {
+    id: 'shopify',
+    // `window.Shopify` is set by the platform, not the theme, so it is the one
+    // reliable marker. A non-Shopify host stays inert rather than polling a URL
+    // that will never answer.
+    detect: () => { var _a; return typeof ((_a = window.Shopify) === null || _a === void 0 ? void 0 : _a.shop) === 'string'; },
+    readCart: async () => {
+        const url = cartUrl();
+        if (!url) {
+            logger.info('BlotoutPopup SDK: cart route is not same-origin; ignored');
+            return undefined;
+        }
+        try {
+            const response = await fetch(url, {
+                method: 'GET',
+                credentials: 'same-origin',
+                headers: { Accept: 'application/json' },
+                signal: readSignal(),
+            });
+            if (!response.ok) {
+                return undefined;
+            }
+            const snapshot = toSnapshot(await response.json());
+            if (!snapshot) {
+                logger.info('BlotoutPopup SDK: unexpected cart.js shape; cart ignored');
+            }
+            return snapshot;
+        }
+        catch {
+            // A blocked or offline request is not an empty cart.
+            return undefined;
+        }
+    },
+    watch: (onMutation) => {
+        // No monkey-patching of window.fetch or XMLHttpRequest. A thrown wrapper
+        // would take the storefront's own cart down with it, and a poll catches
+        // every mutation regardless of how the theme performs it.
+        const notify = () => {
+            try {
+                onMutation();
+            }
+            catch {
+                // Never let our own listener escape into the theme's event dispatch.
+            }
+        };
+        let timer;
+        const startPolling = () => {
+            if (timer === undefined) {
+                timer = setInterval(notify, POLL_MS);
+            }
+        };
+        const stopPolling = () => {
+            if (timer !== undefined) {
+                clearInterval(timer);
+                timer = undefined;
+            }
+        };
+        // A background tab cannot be shopping, and a returning shopper may have
+        // changed the cart in another tab, so re-read once on the way back in.
+        const onVisibility = () => {
+            if (document.visibilityState === 'visible') {
+                notify();
+                startPolling();
+            }
+            else {
+                stopPolling();
+            }
+        };
+        for (const name of THEME_CART_EVENTS) {
+            document.addEventListener(name, notify);
+        }
+        document.addEventListener('visibilitychange', onVisibility);
+        // Fires on a back-button restore, where the cart may have moved on.
+        window.addEventListener('pageshow', notify);
+        if (document.visibilityState === 'visible') {
+            startPolling();
+        }
+        return () => {
+            stopPolling();
+            for (const name of THEME_CART_EVENTS) {
+                document.removeEventListener(name, notify);
+            }
+            document.removeEventListener('visibilitychange', onVisibility);
+            window.removeEventListener('pageshow', notify);
+        };
+    },
+};
+
+var _a, _b;
+var _c;
+if (typeof window !== 'undefined') {
+    (_a = window[registryKey]) !== null && _a !== void 0 ? _a : (window[registryKey] = {});
+    (_b = (_c = window[registryKey]).cartAdapter) !== null && _b !== void 0 ? _b : (_c.cartAdapter = shopifyCartAdapter);
+}