fetch_util 0.5.2 → 0.6.0

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_pull_diff_request_state.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudPullDiffRequestState
+        private
+
+        def bitbucket_cloud_pull_diff_request_state_script
+          <<~'JS'
+            const fetchUtilBitbucketDiffFetchJson = async (url) => {
+              const response = await fetch(url, {
+                credentials: 'same-origin',
+                redirect: 'error',
+                headers: { 'X-Requested-With': 'XMLHttpRequest', Accept: 'application/json' }
+              });
+              if (response.url && new URL(response.url, location.href).origin !== location.origin) {
+                throw new Error('cross-origin Bitbucket API response');
+              }
+              if (!response.ok) throw new Error(`Bitbucket API returned HTTP ${response.status}`);
+              const payload = await response.json();
+              if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+                throw new Error('invalid Bitbucket API payload');
+              }
+              return payload;
+            };
+
+            const fetchUtilBitbucketDiffProxyUrl = (value, product) => {
+              let parsed;
+              try { parsed = new URL(value, product.metadataUrl); } catch (_error) { return null; }
+              if (!/^https?:$/.test(parsed.protocol) || parsed.username || parsed.password) return null;
+              const match = parsed.pathname.match(
+                /^(?:\/!api)?\/2\.0\/repositories\/([^/]+)\/([^/]+)\/(pullrequests\/(\d+)\/diffstat|diffstat\/(.+))\/?$/
+              );
+              const decode = (item) => { try { return decodeURIComponent(item); } catch (_error) { return ''; } };
+              if (!match || decode(match[1]).toLowerCase() !== product.route.workspace.toLowerCase() ||
+                  decode(match[2]).toLowerCase() !== product.route.repository.toLowerCase()) return null;
+              const pullRequestId = match[4] || parsed.searchParams.get('from_pullrequest_id');
+              if (pullRequestId !== product.route.number) return null;
+              const proxyPath = parsed.pathname.replace(/^(?:\/!api)?\/2\.0/, product.proxyPrefix);
+              return location.origin + proxyPath + parsed.search;
+            };
+
+            const fetchUtilBitbucketDiffRecord = (record) => {
+              if (!record || typeof record !== 'object' || Array.isArray(record)) return false;
+              const oldPath = record.old && typeof record.old === 'object' && record.old.path;
+              const newPath = record.new && typeof record.new === 'object' && record.new.path;
+              return !!(String(oldPath || '').trim() || String(newPath || '').trim());
+            };
+
+            const fetchUtilBitbucketDiffRequest = async (product) => {
+              const metadata = await fetchUtilBitbucketDiffFetchJson(product.metadataUrl);
+              const repository = ((metadata.destination || {}).repository || {});
+              if (String(metadata.id || '') !== product.route.number ||
+                  String(repository.full_name || '').toLowerCase() !==
+                    `${product.route.workspace}/${product.route.repository}`.toLowerCase()) {
+                throw new Error('Bitbucket API pull request identity mismatch');
+              }
+              const firstUrl = fetchUtilBitbucketDiffProxyUrl(
+                metadata.links && metadata.links.diffstat && metadata.links.diffstat.href,
+                product
+              );
+              if (!firstUrl) throw new Error('missing trusted Bitbucket diffstat route');
+
+              const records = [];
+              const seen = new Set();
+              let expectedCount = null;
+              let pageUrl = firstUrl;
+              while (pageUrl) {
+                if (seen.has(pageUrl)) throw new Error('repeated Bitbucket diffstat continuation');
+                seen.add(pageUrl);
+                const page = await fetchUtilBitbucketDiffFetchJson(pageUrl);
+                const hasSize = Object.prototype.hasOwnProperty.call(page, 'size');
+                if (!Array.isArray(page.values) || (hasSize && (!Number.isInteger(page.size) || page.size < 0)) ||
+                    (hasSize && expectedCount !== null && page.size !== expectedCount)) {
+                  throw new Error('incomplete Bitbucket diffstat payload');
+                }
+                if (hasSize) expectedCount = page.size;
+                if (!page.values.every(fetchUtilBitbucketDiffRecord)) {
+                  throw new Error('invalid Bitbucket diffstat record');
+                }
+                records.push(...page.values);
+                if (page.next) {
+                  pageUrl = fetchUtilBitbucketDiffProxyUrl(page.next, product);
+                  if (!pageUrl) throw new Error('untrusted Bitbucket diffstat continuation');
+                } else {
+                  pageUrl = null;
+                }
+              }
+              if (expectedCount !== null && records.length !== expectedCount) {
+                throw new Error('incomplete Bitbucket diffstat payload');
+              }
+              return { metadata, records };
+            };
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_pull_diff_state.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudPullDiffState
+        private
+
+        def bitbucket_cloud_pull_diff_state_script
+          <<~JS
+            (() => {
+              #{bitbucket_cloud_pull_diff_product_state_script}
+              #{bitbucket_cloud_pull_diff_request_state_script}
+              const product = fetchUtilBitbucketDiffProduct();
+              if (!product.product) return { product: false, ready: false, loading: false, signature: '' };
+              const routeKey = [product.route.workspace, product.route.repository, product.route.number].join(':');
+              let prepared = window.__fetchUtilBitbucketPullDiff;
+              if (!prepared || prepared.routeKey !== routeKey) {
+                prepared = {
+                  status: product.error ? 'failed' : 'loading',
+                  reason: product.error || '', routeKey, route: product.route, metadata: null, values: []
+                };
+                window.__fetchUtilBitbucketPullDiff = prepared;
+                if (!product.error) {
+                  fetchUtilBitbucketDiffRequest(product).then((result) => {
+                    if (window.__fetchUtilBitbucketPullDiff !== prepared || prepared.status !== 'loading') return;
+                    Object.assign(prepared, {
+                      status: 'ready', reason: '', metadata: result.metadata, values: result.records
+                    });
+                  }).catch((error) => {
+                    if (window.__fetchUtilBitbucketPullDiff !== prepared || prepared.status !== 'loading') return;
+                    prepared.status = 'failed';
+                    prepared.reason = String(error && error.message || error || 'Bitbucket diffstat preparation failed');
+                  });
+                }
+              }
+              const loading = prepared.status === 'loading';
+              const ready = prepared.status === 'ready' || prepared.status === 'failed';
+              const signature = [prepared.status, prepared.reason || '', prepared.values.length].join(':');
+              return { product: true, ready, loading, signature };
+            })()
+          JS
+        end
+
+        def fail_bitbucket_cloud_pull_diff_preparation(page)
+          safe_evaluate(page, <<~'JS', default: false)
+            (() => {
+              const prepared = window.__fetchUtilBitbucketPullDiff;
+              if (!prepared || prepared.status !== 'loading') return false;
+              prepared.status = 'failed';
+              prepared.reason = 'Bitbucket diffstat preparation timed out';
+              return true;
+            })()
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_pull_resource_modules.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      autoload :BitbucketCloudPullDiffProductState,
+               "fetch_util/browser/site_stabilization/bitbucket_cloud_pull_diff_product_state"
+      autoload :BitbucketCloudPullDiffRequestState,
+               "fetch_util/browser/site_stabilization/bitbucket_cloud_pull_diff_request_state"
+      autoload :BitbucketCloudPullDiffState,
+               "fetch_util/browser/site_stabilization/bitbucket_cloud_pull_diff_state"
+      autoload :BitbucketCloudPullResourceState,
+               "fetch_util/browser/site_stabilization/bitbucket_cloud_pull_resource_state"
+      autoload :BitbucketCloudPullResources,
+               "fetch_util/browser/site_stabilization/bitbucket_cloud_pull_resources"
+
+      module BitbucketCloudPullResourceModules
+        include BitbucketCloudPullDiffProductState
+        include BitbucketCloudPullDiffRequestState
+        include BitbucketCloudPullDiffState
+        include BitbucketCloudPullResourceState
+        include BitbucketCloudPullResources
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_pull_resource_state.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudPullResourceState
+        private
+
+        def bitbucket_cloud_pull_resource_state_script
+          <<~JS
+            (() => {
+              if (location.pathname.endsWith("/diff") || location.pathname.endsWith("/diff/")) {
+                return (#{bitbucket_cloud_pull_diff_state_script});
+              }
+              return (#{bitbucket_cloud_pull_commit_resource_state_script});
+            })()
+          JS
+        end
+
+        def bitbucket_cloud_pull_commit_resource_state_script
+          <<~'JS'
+            (() => {
+              const match = location.pathname.match(/^\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)\/commits\/?$/);
+              if (!match) return { product: false, ready: false, loading: false, signature: '' };
+              const decode = (value) => { try { return decodeURIComponent(value); } catch (_error) { return ''; } };
+              const workspace = decode(match[1]);
+              const repository = decode(match[2]);
+              if (!workspace || !repository || workspace.includes('/') || repository.includes('/')) {
+                return { product: false, ready: false, loading: false, signature: '' };
+              }
+              const current = (((window.__initial_state__ || {}).section || {}).repository || {}).currentRepository || {};
+              const publicRepository = current.is_private === false || current.isPrivate === false || current.visibility === 'public';
+              const runtime = current.type === 'repository' && publicRepository &&
+                String(current.full_name || '').toLowerCase() === `${workspace}/${repository}`.toLowerCase();
+              const application = document.querySelector('meta[name="application-name"]');
+              const branded = /^Bitbucket$/i.test((application && application.content || '').trim());
+              const asset = Array.from(document.querySelectorAll('script[src], link[href]'))
+                .some((node) => {
+                  const value = node.getAttribute('src') || node.getAttribute('href') || '';
+                  return /(?:frontbucket|bbc-frontbucket-static|bitbucket)[^/]*\/(?:assets|static)\//i.test(value) ||
+                    /\/(?:assets|static)\/[^?#]*(?:frontbucket|bitbucket)/i.test(value);
+                });
+              const header = document.querySelector('[data-testid="pr-header"]');
+              const product = runtime && branded && !!(header || asset);
+              if (!product) return { product: false, ready: false, loading: false, signature: '' };
+
+              const panel = document.querySelector('[role="tabpanel"][id^="pull-request-tabs-"]');
+              const wrapper = document.querySelector('[data-qa^="commit-hash-wrapper-"]');
+              const root = panel || (wrapper && wrapper.closest('table, [role="grid"]'));
+
+              const visible = (node) => {
+                let currentNode = node;
+                while (currentNode && currentNode !== document) {
+                  const style = getComputedStyle(currentNode);
+                  if (currentNode.hidden || style.display === 'none') return false;
+                  currentNode = currentNode.parentElement;
+                }
+                const style = getComputedStyle(node);
+                return style.visibility !== 'hidden' && style.visibility !== 'collapse';
+              };
+              const seen = new Set();
+              const rows = Array.from(root ? root.querySelectorAll('a[aria-label^="Commit: "][href*="/commits/"]') : [])
+                .map((link) => {
+                  const label = (link.getAttribute('aria-label') || '').trim().match(/^Commit:\s*([0-9a-f]{7,40})$/i);
+                  const row = link.closest('tr, [role="row"]');
+                  try {
+                    const url = new URL(link.href, location.href);
+                    const path = url.pathname.match(/^\/([^/]+)\/([^/]+)\/commits\/([0-9a-f]{40})\/?$/i);
+                    if (!label || !row || !visible(row) || url.origin !== location.origin || !path) return null;
+                    if (decode(path[1]) !== workspace || decode(path[2]) !== repository) return null;
+                    if (!path[3].toLowerCase().startsWith(label[1].toLowerCase())) return null;
+                    const hash = path[3].toLowerCase();
+                    if (seen.has(hash)) return null;
+                    seen.add(hash);
+                    return { row, hash, href: url.href };
+                  } catch (_error) {
+                    return null;
+                  }
+                }).filter(Boolean);
+              const loading = Array.from(document.querySelectorAll(
+                '[aria-busy="true"], [data-testid*="loading"], [data-testid*="spinner"], .loading, .spinner'
+              )).some(visible);
+              const signature = rows.map(({ row, hash, href }) =>
+                `${hash}:${href}:${(row.textContent || '').replace(/\s+/g, ' ').trim()}`
+              ).join('|');
+              return { product: true, ready: !loading && rows.length > 0, loading, signature };
+            })()
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_pull_resources.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudPullResources
+        BITBUCKET_CLOUD_PULL_RESOURCE_STABILIZATION_PROFILE = {
+          host: true,
+          path_query: ->(uri) { uri.path.match?(%r{\A/[^/]+/[^/]+/pull-requests/\d+/(?:commits|diff)/?\z}) },
+          strategy: :stabilize_bitbucket_cloud_pull_resource,
+          fallthrough: true,
+          notes: "Wait for product-matched Bitbucket Cloud pull-request commit or diff resources.",
+          tests: "spec/fetch_util/browser_stabilization_spec.rb"
+        }.freeze
+
+        private
+
+        def stabilize_bitbucket_cloud_pull_resource(page, deadline: stabilization_deadline)
+          last_signature = nil
+          stable_observations = 0
+          incomplete_signature = nil
+          incomplete_observations = 0
+          terminal_incomplete = false
+          observed = retry_until_timeout(
+            capped_timeout(6.0, deadline: deadline),
+            interval: 0.1,
+            deadline: deadline
+          ) do
+            state = safe_evaluate(page, bitbucket_cloud_pull_resource_state_script, default: nil)
+            return false if state.is_a?(Hash) && state["product"] == false
+            next false unless state.is_a?(Hash) && state["product"]
+
+            unless state["ready"]
+              last_signature = nil
+              stable_observations = 0
+              if state["loading"]
+                incomplete_signature = nil
+                incomplete_observations = 0
+              elsif state["signature"] == incomplete_signature
+                incomplete_observations += 1
+              else
+                incomplete_signature = state["signature"]
+                incomplete_observations = 1
+              end
+              if incomplete_observations >= 10
+                terminal_incomplete = true
+                next true
+              end
+              next false
+            end
+
+            incomplete_signature = nil
+            incomplete_observations = 0
+            if state["signature"] == last_signature
+              stable_observations += 1
+            else
+              last_signature = state["signature"]
+              stable_observations = 1
+            end
+            stable_observations >= 3
+          end
+
+          return false if terminal_incomplete
+
+          fail_bitbucket_cloud_pull_diff_preparation(page) unless observed
+
+          settle_after_stabilization(0.5, deadline: deadline) if observed
+          !!observed
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_thread_state.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudThreadState
+        private
+
+        def bitbucket_cloud_thread_state_script
+          <<~'JS'
+            (() => {
+              const match = location.pathname.match(/^\/([^/]+)\/([^/]+)\/pull-requests\/(\d+)(?:\/overview)?\/?$/);
+              if (!match) return { product: false, ready: false, loading: false, signature: '' };
+
+              const decoded = (value) => {
+                try { return decodeURIComponent(value); } catch (_error) { return value; }
+              };
+              const community = `${decoded(match[1])}/${decoded(match[2])}`.toLowerCase();
+              const state = window.__initial_state__ || {};
+              const repository = (((state.section || {}).repository || {}).currentRepository) || null;
+              const publicRepository = !!repository && (
+                repository.is_private === false || repository.isPrivate === false || repository.visibility === 'public'
+              );
+              const runtime = publicRepository && repository.type === 'repository' &&
+                String(repository.full_name || '').trim().toLowerCase() === community;
+              const application = document.querySelector('meta[name="application-name"]');
+              const branded = /^Bitbucket$/i.test((application && application.content || '').trim());
+              const asset = Array.from(document.querySelectorAll('script[src], link[href]')).some((node) => {
+                const value = node.getAttribute('src') || node.getAttribute('href') || '';
+                return /(?:frontbucket|bbc-frontbucket-static|bitbucket)[^/]*\/(?:assets|static)\//i.test(value) ||
+                  /\/(?:assets|static)\/[^?#]*(?:frontbucket|bitbucket)/i.test(value);
+              });
+              const header = document.querySelector('[data-testid="pr-header"]');
+              const root = header && (header.closest('main') || document.querySelector('main') || header.parentElement) ||
+                document.querySelector('main');
+              const opening = root && root.querySelector(
+                '#pull-request-description-panel, section[aria-label="Pull request description"], section[aria-label="Description"]'
+              );
+              const product = runtime && branded && !!(header || asset);
+              if (!product) return { product: false, ready: false, loading: false, signature: '' };
+
+              const nodeVisible = (node) => {
+                let current = node;
+                while (current && current !== document) {
+                  const style = getComputedStyle(current);
+                  if (current.hidden || style.display === 'none') return false;
+                  current = current.parentElement;
+                }
+                const visibility = getComputedStyle(node).visibility;
+                return visibility !== 'hidden' && visibility !== 'collapse';
+              };
+              const subtreeVisible = (node) => {
+                if (nodeVisible(node)) return true;
+                return Array.from(node.querySelectorAll('*')).some((child) => {
+                  const material = (child.textContent || '').trim() ||
+                    child.matches('img[src], video, pre, table, ul, ol');
+                  return material && nodeVisible(child);
+                });
+              };
+              const comments = Array.from(root.querySelectorAll('[data-testid="comment"]')).filter(subtreeVisible);
+              const owned = (node, selector) => Array.from(node.querySelectorAll(selector)).find(
+                (candidate) => candidate.closest('[data-testid="comment"]') === node
+              );
+              const loading = Array.from(root.querySelectorAll(
+                '[aria-busy="true"], [data-testid*="loading" i], [data-testid*="spinner" i], .spinner, .loading'
+              )).some(subtreeVisible);
+              const openingReady = !!opening && subtreeVisible(opening) && !!(
+                (opening.textContent || '').trim() || opening.querySelector('img[src], video, pre, table, ul, ol')
+              );
+              const commentBodies = comments.filter((node) => {
+                const body = owned(node, '[data-testid="comment-content"], comment-content');
+                return body && subtreeVisible(body) && !!((body.textContent || '').trim() || body.querySelector('img[src], pre, table'));
+              });
+              const explicitZero = /\b0\s+comments?\b/i.test(root.textContent || '');
+              const rowSignatures = commentBodies.map((node, index) => {
+                const link = owned(node, 'a[href*="#comment-"]');
+                return node.id || node.getAttribute('data-comment-id') || (link && link.href) ||
+                  `${index}:${(node.textContent || '').trim().slice(0, 120)}`;
+              });
+              return {
+                product: true,
+                ready: !!header && openingReady && !loading && (commentBodies.length > 0 || explicitZero),
+                loading: loading,
+                signature: [openingReady, commentBodies.length, explicitZero, loading, rowSignatures.join('|')].join(':')
+              };
+            })()
+          JS
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/bitbucket_cloud_threads.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module BitbucketCloudThreads
+        BITBUCKET_CLOUD_THREAD_STABILIZATION_PROFILE = {
+          host: true,
+          path_query: ->(uri) { uri.path.match?(%r{\A/[^/]+/[^/]+/pull-requests/\d+(?:/overview)?/?\z}) },
+          strategy: :stabilize_bitbucket_cloud_thread,
+          fallthrough: true,
+          notes: "Wait for product-matched Bitbucket Cloud pull-request conversations.",
+          tests: "spec/fetch_util/browser_stabilization_spec.rb"
+        }.freeze
+
+        private
+
+        def stabilize_bitbucket_cloud_thread(page, deadline: stabilization_deadline)
+          last_signature = nil
+          stable_observations = 0
+          incomplete_signature = nil
+          incomplete_observations = 0
+          terminal_incomplete = false
+          observed = retry_until_timeout(
+            capped_timeout(6.0, deadline: deadline),
+            interval: 0.1,
+            deadline: deadline
+          ) do
+            state = safe_evaluate(page, bitbucket_cloud_thread_state_script, default: nil)
+            return false if state.is_a?(Hash) && state["product"] == false
+            next false unless state.is_a?(Hash) && state["product"]
+
+            unless state["ready"]
+              last_signature = nil
+              stable_observations = 0
+              if state["loading"]
+                incomplete_signature = nil
+                incomplete_observations = 0
+              elsif state["signature"] == incomplete_signature
+                incomplete_observations += 1
+              else
+                incomplete_signature = state["signature"]
+                incomplete_observations = 1
+              end
+              if incomplete_observations >= 10
+                terminal_incomplete = true
+                next true
+              end
+              next false
+            end
+
+            incomplete_signature = nil
+            incomplete_observations = 0
+            if state["signature"] == last_signature
+              stable_observations += 1
+            else
+              last_signature = state["signature"]
+              stable_observations = 1
+            end
+            stable_observations >= 3
+          end
+
+          return false if terminal_incomplete
+
+          settle_after_stabilization(0.5, deadline: deadline) if observed
+          !!observed
+        end
+      end
+    end
+  end
+end

data/lib/fetch_util/browser/site_stabilization/community_and_marketplace.rb

@@ -22,17 +22,18 @@ module FetchUtil
 
         private
 
-        def stabilize_reddit(page)
-          retry_until_timeout(capped_timeout(3.0), interval: 0.1) do
+        def stabilize_reddit(page, deadline: stabilization_deadline)
+          ready = retry_until_timeout(capped_timeout(3.0, deadline: deadline), interval: 0.1, deadline: deadline) do
             dismiss_reddit_cookie_dialog(page)
             reddit_content_ready?(page)
           end
 
-          settle_after_stabilization(0.25)
-          dismiss_reddit_cookie_dialog(page)
+          settle_after_stabilization(0.25, deadline: deadline)
+          dismiss_reddit_cookie_dialog(page) if stabilization_time_remaining?(deadline)
+          ready
         end
 
-        def stabilize_ebay_search(page)
+        def stabilize_ebay_search(page, deadline: stabilization_deadline)
           accepted_cookies = false
           cookie_config = consent_config(
             accept_labels: [
@@ -46,7 +47,7 @@ module FetchUtil
             ]
           )
 
-          retry_until_timeout(capped_timeout(6.0), interval: 0.15) do
+          retry_until_timeout(capped_timeout(6.0, deadline: deadline), interval: 0.15, deadline: deadline) do
             accepted_cookies ||= click_visible_button_by_text(
               page,
               consent_accept_labels(cookie_config),
@@ -66,15 +67,13 @@ module FetchUtil
             state["itemCount"].to_i >= 4 || (state["challengeVisible"] ? 0.35 : false)
           end
 
-          settle_after_stabilization(0.25) if accepted_cookies
+          settle_after_stabilization(0.25, deadline: deadline) if accepted_cookies
         end
 
         def reddit_content_ready?(page)
-          page.evaluate(<<~JS)
+          safe_evaluate(page, <<~JS, default: false)
             !!document.querySelector('shreddit-post, faceplate-screen-reader-content, shreddit-comment, [data-testid="comment"]')
           JS
-        rescue Ferrum::JavaScriptError
-          false
         end
 
         def dismiss_reddit_cookie_dialog(page)

data/lib/fetch_util/browser/site_stabilization/facebook_stabilization.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module FetchUtil
+  class Browser
+    module SiteStabilization
+      module FacebookStabilization
+        private
+
+        def stabilize_facebook(page, deadline: stabilization_deadline)
+          wait_for_idle_or_content(page, deadline: deadline) if @wait_for_idle
+          return false unless stabilization_time_remaining?(deadline)
+
+          social_login_phase_pause(deadline: deadline)
+          return false unless stabilization_time_remaining?(deadline)
+
+          dismiss_facebook_cookie_dialog(page)
+          return false unless stabilization_time_remaining?(deadline)
+
+          social_login_phase_pause(deadline: deadline)
+          return false unless stabilization_time_remaining?(deadline)
+
+          retry_until_timeout(capped_timeout(5.0, deadline: deadline), deadline: deadline) do
+            dismiss_facebook_login_dialog(page)
+          end
+          return false unless stabilization_time_remaining?(deadline)
+
+          social_login_phase_pause(deadline: deadline)
+        end
+
+        def dismiss_facebook_cookie_dialog(page)
+          config = consent_config(
+            accept_labels: ["decline optional cookies", "optionale cookies ablehnen", "refuser les cookies optionnels",
+                            "rechazar cookies opcionales", "rifiuta i cookie opzionali"],
+            fallback_labels: ["allow all cookies", "alle cookies erlauben", "autoriser tous les cookies", "permitir todas las cookies", "consenti tutti i cookie"]
+          )
+
+          click_visible_button_by_text(
+            page,
+            consent_accept_labels(config),
+            consent_fallback_labels(config),
+            selectors: consent_button_selectors(config)
+          )
+        end
+
+        def dismiss_facebook_login_dialog(page)
+          dismiss_overlay_dialog(
+            page,
+            close_selectors: ['[aria-label="Close"]', '[aria-label="close"]'],
+            dialog_selectors: ['[role="dialog"]', '[aria-modal="true"]'],
+            dialog_pattern: "log in|sign up|create (?:new )?account|see more from"
+          )
+        end
+      end
+    end
+  end
+end