@salla.sa/twilight-components 2.14.455 → 2.14.456

package/dist/collection/components/salla-trust-badges/salla-trust-badges.js

@@ -10,10 +10,176 @@ export class SallaTrustBadges {
         this.dark = false;
         this.commercialRegisterLabel = '';
         this.freelanceLabel = '';
+        this.cachedChain = [];
+        this.enforceVisibility = () => {
+            const host = this.hostEl;
+            if (!host || !host.isConnected)
+                return;
+            const badgeData = this.getBadgeData();
+            if (!badgeData)
+                return;
+            if (this.isHostVisible(host))
+                return;
+            for (const el of this.getAncestorChain(host)) {
+                const computed = getComputedStyle(el);
+                if (computed.display === 'none') {
+                    el.style.setProperty('display', 'flex', 'important');
+                }
+                if (computed.visibility === 'hidden' || computed.visibility === 'collapse') {
+                    el.style.setProperty('visibility', 'visible', 'important');
+                }
+                if (parseFloat(computed.opacity) < SallaTrustBadges.OPACITY_THRESHOLD) {
+                    el.style.setProperty('opacity', '1', 'important');
+                }
+                if (computed.contentVisibility === 'hidden') {
+                    el.style.setProperty('content-visibility', 'visible', 'important');
+                }
+            }
+            this.logHidePreventedOnce(badgeData.type);
+        };
+        this.runEnforce = () => {
+            this.clearEnforceTimers();
+            this.enforceVisibility();
+        };
     }
     componentWillLoad() {
         this.initializeTranslations();
     }
+    connectedCallback() {
+        this.setupVisibilityGuard();
+    }
+    componentDidLoad() {
+        this.scheduleEnforce();
+    }
+    componentDidRender() {
+        this.scheduleEnforce();
+    }
+    disconnectedCallback() {
+        this.attrObserver?.disconnect();
+        this.attrObserver = undefined;
+        this.moveObserver?.disconnect();
+        this.moveObserver = undefined;
+        this.cachedChain = [];
+        this.clearEnforceTimers();
+    }
+    getAncestorChain(host) {
+        const chain = [];
+        let el = host;
+        while (el) {
+            chain.push(el);
+            if (el === document.documentElement)
+                break;
+            el = el.parentElement;
+        }
+        return chain;
+    }
+    didChainChange(host) {
+        const now = this.getAncestorChain(host);
+        if (now.length !== this.cachedChain.length)
+            return true;
+        for (let i = 0; i < now.length; i++) {
+            if (now[i] !== this.cachedChain[i])
+                return true;
+        }
+        return false;
+    }
+    isHostVisible(host) {
+        return typeof host.checkVisibility === 'function'
+            ? host.checkVisibility({
+                contentVisibilityAuto: true,
+                opacityProperty: true,
+                visibilityProperty: true,
+            })
+            : this.isVisibleFallback(host);
+    }
+    isVisibleFallback(host) {
+        let el = host;
+        while (el) {
+            const cs = getComputedStyle(el);
+            if (cs.display === 'none')
+                return false;
+            if (cs.visibility === 'hidden' || cs.visibility === 'collapse')
+                return false;
+            if (parseFloat(cs.opacity) < SallaTrustBadges.OPACITY_THRESHOLD)
+                return false;
+            if (cs.contentVisibility === 'hidden')
+                return false;
+            if (el === document.documentElement)
+                break;
+            el = el.parentElement;
+        }
+        return true;
+    }
+    // Log a prevented hide attempt once per device; never let telemetry block the repair.
+    logHidePreventedOnce(type) {
+        try {
+            if (salla.storage.get(SallaTrustBadges.HIDE_PREVENTED_LOGGED_KEY))
+                return;
+            salla.analytics?.log('salla::trust-badges.hide-prevented', { type });
+            salla.storage.set(SallaTrustBadges.HIDE_PREVENTED_LOGGED_KEY, true);
+        }
+        catch { }
+    }
+    clearEnforceTimers() {
+        if (this.enforceTimer !== undefined) {
+            clearTimeout(this.enforceTimer);
+            this.enforceTimer = undefined;
+        }
+        if (this.maxWaitTimer !== undefined) {
+            clearTimeout(this.maxWaitTimer);
+            this.maxWaitTimer = undefined;
+        }
+    }
+    scheduleEnforce() {
+        // Debounce waits for an entrance animation to settle; maxWait bounds it so endless chain mutations can't starve the repair.
+        if (this.enforceTimer !== undefined)
+            clearTimeout(this.enforceTimer);
+        this.enforceTimer = setTimeout(this.runEnforce, SallaTrustBadges.ENFORCE_DEBOUNCE_MS);
+        if (this.maxWaitTimer === undefined) {
+            this.maxWaitTimer = setTimeout(this.runEnforce, SallaTrustBadges.ENFORCE_MAX_WAIT_MS);
+        }
+    }
+    setupVisibilityGuard() {
+        const host = this.hostEl;
+        if (!host || typeof MutationObserver === 'undefined')
+            return;
+        this.attrObserver?.disconnect();
+        this.moveObserver?.disconnect();
+        this.attrObserver = new MutationObserver(() => {
+            const h = this.hostEl;
+            if (!h || !h.isConnected)
+                return;
+            if (this.isHostVisible(h))
+                return;
+            this.scheduleEnforce();
+        });
+        this.attachAttrObserver(host);
+        this.moveObserver = new MutationObserver(() => {
+            const h = this.hostEl;
+            if (!h || !h.isConnected)
+                return;
+            if (!this.didChainChange(h))
+                return;
+            this.attachAttrObserver(h);
+            this.scheduleEnforce();
+        });
+        this.moveObserver.observe(document.documentElement, {
+            childList: true,
+            subtree: true,
+        });
+    }
+    attachAttrObserver(host) {
+        if (!this.attrObserver)
+            return;
+        this.attrObserver.disconnect();
+        this.cachedChain = this.getAncestorChain(host);
+        for (const el of this.cachedChain) {
+            this.attrObserver.observe(el, {
+                attributes: true,
+                attributeFilter: ['style', 'class', 'hidden'],
+            });
+        }
+    }
     initializeTranslations() {
         salla.lang.onLoaded(() => {
             // Set translations synchronously
@@ -102,4 +268,9 @@ export class SallaTrustBadges {
             "freelanceLabel": {}
         };
     }
+    static get elementRef() { return "hostEl"; }
 }
+SallaTrustBadges.OPACITY_THRESHOLD = 0.1;
+SallaTrustBadges.ENFORCE_DEBOUNCE_MS = 1500;
+SallaTrustBadges.ENFORCE_MAX_WAIT_MS = 3000;
+SallaTrustBadges.HIDE_PREVENTED_LOGGED_KEY = 'salla::trust-badges-hide-prevented-logged';