Shows true prices including shipping and variants on AliExpress, since sellers often misleadingly put accessory variants as the primary price, not the advertised item.
// ==UserScript==
// @name AliExpress Real Price
// @namespace https://github.com/joshwand/aliexpress-real-price-userscript
// @version 1.0.0
// @description Shows true prices including shipping and variants on AliExpress, since sellers often misleadingly put accessory variants as the primary price, not the advertised item.
// @author Josh Wand
// @license GPL-3.0-or-later
// @copyright 2025 Josh Wand
// @match *://*.aliexpress.com/*
// @match *://*.aliexpress.us/*
// @grant GM.xmlHttpRequest
// @grant GM_addStyle
// @grant GM.getValue
// @grant GM.setValue
// @grant GM.cookie
// @connect aliexpress.us
// @connect aliexpress.com
// @grant GM_listValues
// @grant GM_addStyle
// @grant GM_xmlhttpRequest
// @grant unsafeWindow
// ==/UserScript==
(function() {
'use strict';
// --- Global Cache Disable Flag ---
let isCacheDisabled = false;
// Debug logging utility
const DEBUG = true;
const log = (...args) => {
if (DEBUG) {
const productId = args.find(arg => typeof arg === 'object' && arg?.productId)?.productId || '';
console.log(`[AliExpress Real Price${productId ? ` - ID:${productId}` : ''}]`, ...args);
}
};
// Rate limiter for API calls
class RateLimiter {
constructor(maxRequests = 2, timeWindow = 1000) {
this.maxRequests = maxRequests;
this.timeWindow = timeWindow;
this.requests = [];
this.backoffTime = 1000; // Start with 1 second backoff
this.maxBackoffTime = 32000; // Max backoff of 32 seconds
}
async waitForSlot() {
// Remove old requests outside the time window
const now = Date.now();
this.requests = this.requests.filter(time => now - time < this.timeWindow);
// If we have capacity, add the request
if (this.requests.length < this.maxRequests) {
this.requests.push(now);
return;
}
// Wait for the oldest request to expire
const oldestRequest = this.requests[0];
const waitTime = this.timeWindow - (now - oldestRequest);
await new Promise(resolve => setTimeout(resolve, waitTime));
return this.waitForSlot();
}
async executeWithBackoff(fn) {
while (true) {
try {
await this.waitForSlot();
const result = await fn();
this.backoffTime = 1000; // Reset backoff on success
return result;
} catch (error) {
if (error.message?.includes('FAIL_SYS_ILLEGAL_ACCESS')) {
log(`Rate limit exceeded, backing off for ${this.backoffTime}ms`);
await new Promise(resolve => setTimeout(resolve, this.backoffTime));
this.backoffTime = Math.min(this.backoffTime * 2, this.maxBackoffTime);
continue;
}
throw error;
}
}
}
}
// Loading Manager for global progress
class LoadingManager {
constructor() {
this.totalItems = 0;
this.completedItems = 0;
this.createElements();
this.addStyles(); // Add styles for the elements
}
createElements() {
// Create main container for status text and clear button
this.container = document.createElement('div');
this.container.className = 'ali-real-price-status-container';
// this.container.title = 'AliExpress Real Price UserScript';
// Create icon container for collapsed state
this.iconContainer = document.createElement('div');
this.iconContainer.className = 'ali-real-price-icon';
this.iconContainer.innerHTML = '🐟'; // Fish icon - because the prices are fishy
this.iconContainer.title = 'Hmm, something is fishy here...';
this.container.appendChild(this.iconContainer);
// Create expandable content container
this.expandableContent = document.createElement('div');
this.expandableContent.className = 'ali-real-price-expandable-content';
// Create status text
this.statusText = document.createElement('div');
this.statusText.className = 'ali-real-price-status';
this.expandableContent.appendChild(this.statusText);
// Create settings container with disclosure arrow
this.settingsContainer = document.createElement('div');
this.settingsContainer.className = 'ali-real-price-settings-container';
// Add disclosure arrow
this.disclosureArrow = document.createElement('span');
this.disclosureArrow.className = 'ali-real-price-disclosure-arrow collapsed';
// Create a separate text node for the arrow symbol
this.arrowSymbol = document.createTextNode('▶');
this.disclosureArrow.appendChild(this.arrowSymbol);
this.disclosureArrow.title = 'Advanced Options';
// Create custom tooltip
this.tooltip = document.createElement('div');
this.tooltip.className = 'ali-real-price-tooltip';
this.tooltip.textContent = 'Advanced Options';
this.disclosureArrow.appendChild(this.tooltip);
// Restore click handler
this.disclosureArrow.onclick = () => {
const container = this.settingsContainer;
const isExpanding = !container.classList.contains('expanded');
container.classList.toggle('expanded');
this.disclosureArrow.classList.toggle('collapsed');
this.arrowSymbol.nodeValue = isExpanding ? '▼' : '▶';
};
// Remove default title to prevent both tooltips
this.disclosureArrow.removeAttribute('title');
this.expandableContent.appendChild(this.disclosureArrow);
// Settings content (initially hidden)
this.settingsContent = document.createElement('div');
this.settingsContent.className = 'ali-real-price-settings-content';
// --- Create Clear Cache button ---
this.clearCacheButton = document.createElement('span');
this.clearCacheButton.className = 'ali-real-price-clear-cache';
this.clearCacheButton.textContent = 'Clear Cache';
this.clearCacheButton.onclick = async () => {
await clearCacheAndReload();
};
this.settingsContent.appendChild(this.clearCacheButton);
// --- Create Disable Cache Checkbox ---
this.disableCacheContainer = document.createElement('div');
this.disableCacheContainer.className = 'ali-real-price-disable-cache-container';
this.disableCacheCheckbox = document.createElement('input');
this.disableCacheCheckbox.type = 'checkbox';
this.disableCacheCheckbox.id = 'ali-real-price-disable-cache-checkbox';
this.disableCacheCheckbox.className = 'ali-real-price-disable-cache-checkbox';
log(`[LoadingManager.createElements] Setting checkbox state based on isCacheDisabled: ${isCacheDisabled}`);
this.disableCacheCheckbox.checked = isCacheDisabled;
this.disableCacheCheckbox.addEventListener('change', handleDisableCacheChange);
this.disableCacheLabel = document.createElement('label');
this.disableCacheLabel.htmlFor = 'ali-real-price-disable-cache-checkbox';
this.disableCacheLabel.textContent = 'Disable Cache';
this.disableCacheLabel.className = 'ali-real-price-disable-cache-label';
this.disableCacheContainer.appendChild(this.disableCacheCheckbox);
this.disableCacheContainer.appendChild(this.disableCacheLabel);
this.settingsContent.appendChild(this.disableCacheContainer);
// Add settings content to settings container
this.settingsContainer.appendChild(this.settingsContent);
this.expandableContent.appendChild(this.settingsContainer);
// Add expandable content to main container
this.container.appendChild(this.expandableContent);
document.body.appendChild(this.container);
// Add hover behavior
this.container.addEventListener('mouseenter', () => {
this.container.classList.add('expanded');
});
this.container.addEventListener('mouseleave', () => {
// Only collapse if we're done loading AND the mouse isn't in the container
if (this.completedItems >= this.totalItems && !this.container.matches(':hover')) {
this.container.classList.remove('expanded');
// Also collapse settings if expanded
this.settingsContainer.classList.remove('expanded');
this.disclosureArrow.classList.add('collapsed');
this.arrowSymbol.nodeValue = '▶';
}
});
}
// Add CSS styles
addStyles() {
const existingStyle = document.getElementById('ali-real-price-styles');
if (existingStyle) {
existingStyle.remove();
}
const styleElement = document.createElement('style');
styleElement.id = 'ali-real-price-styles';
styleElement.textContent = `
.ali-real-price-status-container {
position: fixed;
top: 10px;
right: 10px;
z-index: 99999;
background-color: rgba(0, 0, 0, 0.8);
color: white;
padding: 8px;
border-radius: 4px;
box-shadow: 0 2px 5px rgba(0,0,0,0.3);
transition: all 0.3s ease;
cursor: pointer;
display: flex; /* Use flexbox by default */
align-items: flex-start; /* Align items to top */
gap: 8px; /* Space between icon and content */
visibility: hidden; /* Use visibility instead of display: none */
opacity: 0;
}
.ali-real-price-status-container.visible {
visibility: visible;
opacity: 1;
}
.ali-real-price-icon {
font-size: 16px;
flex-shrink: 0; /* Prevent icon from shrinking */
}
.ali-real-price-expandable-content {
display: none;
flex-grow: 1; /* Allow content to grow */
min-width: 0; /* Allow content to shrink if needed */
}
.ali-real-price-status-container.expanded .ali-real-price-expandable-content {
display: block;
}
.ali-real-price-status {
font-size: 12px;
margin-right: 10px;
display: inline-block;
}
.ali-real-price-disclosure-arrow {
font-size: 10px;
margin-left: 5px;
cursor: pointer;
color: #666;
position: relative;
}
.ali-real-price-tooltip {
position: absolute;
background: rgba(0, 0, 0, 0.8);
color: white;
padding: 4px 8px;
border-radius: 4px;
font-size: 11px;
white-space: nowrap;
pointer-events: none;
opacity: 0;
transition: opacity 0.15s;
top: 100%;
margin-top: 4px;
right: 0;
}
/* Show tooltip on hover when collapsed (default state) */
.ali-real-price-disclosure-arrow.collapsed:hover .ali-real-price-tooltip {
opacity: 1;
}
/* Hide tooltip when expanded */
.ali-real-price-disclosure-arrow:hover .ali-real-price-tooltip {
opacity: 0;
}
/* Add a small arrow at the bottom of the tooltip */
.ali-real-price-tooltip:after {
content: '';
position: absolute;
top: -4px;
right: 2px;
border-width: 0 4px 4px 4px;
border-style: solid;
border-color: transparent transparent rgba(0, 0, 0, 0.8) transparent;
}
.ali-real-price-settings-container {
margin-top: 5px;
}
.ali-real-price-settings-content {
display: none;
margin-top: 5px;
padding-top: 5px;
border-top: 1px solid rgba(255, 255, 255, 0.1);
}
.ali-real-price-settings-container.expanded .ali-real-price-settings-content {
display: block;
}
.ali-real-price-clear-cache {
color: #ffc107;
font-size: 11px;
cursor: pointer;
text-decoration: underline;
display: block;
margin-bottom: 5px;
}
.ali-real-price-clear-cache:hover {
color: #ffa000;
}
.ali-real-price-disable-cache-container {
display: flex;
align-items: center;
margin-top: 5px;
}
.ali-real-price-disable-cache-checkbox {
margin: 0 5px 0 0;
cursor: pointer;
}
.ali-real-price-disable-cache-label {
font-size: 11px;
color: #ccc;
cursor: pointer;
user-select: none;
}
`;
document.head.appendChild(styleElement);
}
startLoading(totalItems) {
this.totalItems = totalItems;
this.updateProgress();
this.container.classList.add('visible');
this.container.classList.remove('expanded');
}
itemComplete() {
log(`[itemComplete] Before increment: completed=${this.completedItems}, total=${this.totalItems}`);
this.completedItems++;
// If completedItems exceeds totalItems, update totalItems
if (this.completedItems > this.totalItems) {
this.totalItems = this.completedItems;
}
log(`[itemComplete] After increment: completed=${this.completedItems}, total=${this.totalItems}`);
this.updateProgress();
if (this.completedItems >= this.totalItems) {
// When complete, only collapse if mouse isn't in the container
if (!this.container.matches(':hover')) {
this.container.classList.remove('expanded');
}
}
}
updateProgress() {
log(`[updateProgress] Updating text: completed=${this.completedItems}, total=${this.totalItems}`);
this.statusText.textContent = `Loading prices: ${this.completedItems}/${this.totalItems}`;
// Show expanded state while loading
if (this.completedItems < this.totalItems) {
this.container.classList.add('expanded');
}
}
}
// Global loading manager instance
const loadingManager = new LoadingManager();
// Global rate limiter instance
const rateLimiter = new RateLimiter();
// Global cache instance
let globalCache;
// Function to clear cache and reload
async function clearCacheAndReload() {
try {
if (globalCache) {
log('Clearing cache...');
await globalCache.clear();
alert('AliExpress Real Price cache cleared. Reloading page.');
window.location.reload();
} else {
log('Cache instance not found');
alert('Cache instance not found.');
}
} catch (error) {
log('Error clearing cache:', error);
alert('Error clearing cache. See console for details.');
}
}
log('Script starting...');
// MD5 implementation for sign generation
function md5(string) {
function cmn(q, a, b, x, s, t) {
a = add32(add32(a, q), add32(x, t));
return add32((a << s) | (a >>> (32 - s)), b);
}
function ff(a, b, c, d, x, s, t) {
return cmn((b & c) | ((~b) & d), a, b, x, s, t);
}
function gg(a, b, c, d, x, s, t) {
return cmn((b & d) | (c & (~d)), a, b, x, s, t);
}
function hh(a, b, c, d, x, s, t) {
return cmn(b ^ c ^ d, a, b, x, s, t);
}
function ii(a, b, c, d, x, s, t) {
return cmn(c ^ (b | (~d)), a, b, x, s, t);
}
function md5cycle(x, k) {
let a = x[0], b = x[1], c = x[2], d = x[3];
a = ff(a, b, c, d, k[0], 7, -680876936);
d = ff(d, a, b, c, k[1], 12, -389564586);
c = ff(c, d, a, b, k[2], 17, 606105819);
b = ff(b, c, d, a, k[3], 22, -1044525330);
a = ff(a, b, c, d, k[4], 7, -176418897);
d = ff(d, a, b, c, k[5], 12, 1200080426);
c = ff(c, d, a, b, k[6], 17, -1473231341);
b = ff(b, c, d, a, k[7], 22, -45705983);
a = ff(a, b, c, d, k[8], 7, 1770035416);
d = ff(d, a, b, c, k[9], 12, -1958414417);
c = ff(c, d, a, b, k[10], 17, -42063);
b = ff(b, c, d, a, k[11], 22, -1990404162);
a = ff(a, b, c, d, k[12], 7, 1804603682);
d = ff(d, a, b, c, k[13], 12, -40341101);
c = ff(c, d, a, b, k[14], 17, -1502002290);
b = ff(b, c, d, a, k[15], 22, 1236535329);
a = gg(a, b, c, d, k[1], 5, -165796510);
d = gg(d, a, b, c, k[6], 9, -1069501632);
c = gg(c, d, a, b, k[11], 14, 643717713);
b = gg(b, c, d, a, k[0], 20, -373897302);
a = gg(a, b, c, d, k[5], 5, -701558691);
d = gg(d, a, b, c, k[10], 9, 38016083);
c = gg(c, d, a, b, k[15], 14, -660478335);
b = gg(b, c, d, a, k[4], 20, -405537848);
a = gg(a, b, c, d, k[9], 5, 568446438);
d = gg(d, a, b, c, k[14], 9, -1019803690);
c = gg(c, d, a, b, k[3], 14, -187363961);
b = gg(b, c, d, a, k[8], 20, 1163531501);
a = gg(a, b, c, d, k[13], 5, -1444681467);
d = gg(d, a, b, c, k[2], 9, -51403784);
c = gg(c, d, a, b, k[7], 14, 1735328473);
b = gg(b, c, d, a, k[12], 20, -1926607734);
a = hh(a, b, c, d, k[5], 4, -378558);
d = hh(d, a, b, c, k[8], 11, -2022574463);
c = hh(c, d, a, b, k[11], 16, 1839030562);
b = hh(b, c, d, a, k[14], 23, -35309556);
a = hh(a, b, c, d, k[1], 4, -1530992060);
d = hh(d, a, b, c, k[4], 11, 1272893353);
c = hh(c, d, a, b, k[7], 16, -155497632);
b = hh(b, c, d, a, k[10], 23, -1094730640);
a = hh(a, b, c, d, k[13], 4, 681279174);
d = hh(d, a, b, c, k[0], 11, -358537222);
c = hh(c, d, a, b, k[3], 16, -722521979);
b = hh(b, c, d, a, k[6], 23, 76029189);
a = hh(a, b, c, d, k[9], 4, -640364487);
d = hh(d, a, b, c, k[12], 11, -421815835);
c = hh(c, d, a, b, k[15], 16, 530742520);
b = hh(b, c, d, a, k[2], 23, -995338651);
a = ii(a, b, c, d, k[0], 6, -198630844);
d = ii(d, a, b, c, k[7], 10, 1126891415);
c = ii(c, d, a, b, k[14], 15, -1416354905);
b = ii(b, c, d, a, k[5], 21, -57434055);
a = ii(a, b, c, d, k[12], 6, 1700485571);
d = ii(d, a, b, c, k[3], 10, -1894986606);
c = ii(c, d, a, b, k[10], 15, -1051523);
b = ii(b, c, d, a, k[1], 21, -2054922799);
a = ii(a, b, c, d, k[8], 6, 1873313359);
d = ii(d, a, b, c, k[15], 10, -30611744);
c = ii(c, d, a, b, k[6], 15, -1560198380);
b = ii(b, c, d, a, k[13], 21, 1309151649);
a = ii(a, b, c, d, k[4], 6, -145523070);
d = ii(d, a, b, c, k[11], 10, -1120210379);
c = ii(c, d, a, b, k[2], 15, 718787259);
b = ii(b, c, d, a, k[9], 21, -343485551);
x[0] = add32(a, x[0]);
x[1] = add32(b, x[1]);
x[2] = add32(c, x[2]);
x[3] = add32(d, x[3]);
}
function md5blk(s) {
let i, md5blks = [];
for (i = 0; i < 64; i += 4) {
md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
}
return md5blks;
}
function md5blk_array(a) {
let i, md5blks = [];
for (i = 0; i < 64; i += 4) {
md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
}
return md5blks;
}
function md51(s) {
let n = s.length, state = [1732584193, -271733879, -1732584194, 271733878], i;
for (i = 64; i <= s.length; i += 64) {
md5cycle(state, md5blk(s.substring(i - 64, i)));
}
s = s.substring(i - 64);
let tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
for (i = 0; i < s.length; i++) {
tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
}
tail[i >> 2] |= 0x80 << ((i % 4) << 3);
if (i > 55) {
md5cycle(state, tail);
for (i = 0; i < 16; i++) tail[i] = 0;
}
tail[14] = n * 8;
md5cycle(state, tail);
return state;
}
function md51_array(a) {
let n = a.length, state = [1732584193, -271733879, -1732584194, 271733878], i;
for (i = 64; i <= a.length; i += 64) {
md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
}
a = (i - 64) < a.length ? a.subarray(i - 64) : new Uint8Array(0);
let tail = new Uint8Array(64), len = a.length;
for (i = 0; i < len; i++) {
tail[i] = a[i];
}
tail[len] = 0x80;
if (len > 55) {
md5cycle(state, tail.subarray(0, 64));
for (i = 0; i < 64; i++) tail[i] = 0;
}
for (i = 0; i < 8; i++) tail[56 + i] = (n * 8) >>> (i * 8) & 0xff;
md5cycle(state, tail);
return state;
}
function hex_chr(n) {
return '0123456789abcdef'.charAt(n);
}
function rhex(n) {
let s = '', j = 0;
for (; j < 4; j++) {
s += hex_chr((n >> (j * 8 + 4)) & 0x0F) + hex_chr((n >> (j * 8)) & 0x0F);
}
return s;
}
function hex(x) {
for (let i = 0; i < x.length; i++) {
x[i] = rhex(x[i]);
}
return x.join('');
}
function add32(a, b) {
return (a + b) & 0xFFFFFFFF;
}
if (typeof string !== 'string') string = '';
let result;
if (/[\x80-\xFF]/.test(string)) {
result = hex(md51(unescape(encodeURIComponent(string))));
} else {
result = hex(md51(string));
}
return result;
}
// CSS Styles
const STYLES = `
.ali-real-price-range {
font-weight: bold;
color: #333;
}
.ali-real-price-global-loading {
position: fixed;
top: 0;
left: 0;
right: 0;
background: #2196F3;
height: 3px;
z-index: 10000;
transition: width 0.3s ease-out;
}
.ali-real-price-global-status {
position: fixed;
top: 3px;
right: 10px;
background: rgba(33, 150, 243, 0.9);
color: white;
padding: 8px 12px;
border-radius: 0 0 4px 4px;
font-size: 12px;
z-index: 10000;
transition: opacity 0.3s ease-out;
}
.ali-real-price-median-indicator {
color: #2196F3;
margin-left: 4px;
}
.ali-real-price-distribution {
height: 4px;
background: #eee;
margin: 2px 0;
position: relative;
}
.ali-real-price-distribution-marker {
position: absolute;
width: 2px;
height: 8px;
background: #2196F3;
top: -2px;
}
.ali-real-price-popup {
position: absolute;
z-index: 1000;
background: white;
border-radius: 4px;
box-shadow: 0 2px 8px rgba(0,0,0,0.1);
padding: 12px;
width: 280px;
font-size: 12px;
line-height: 1.5;
}
.ali-real-price-popup ul {
list-style: none;
padding: 0;
margin: 0 0 10px 0;
}
.ali-real-price-popup li {
padding: 4px 0;
border-bottom: 1px solid #f5f5f5;
}
.ali-real-price-popup li.median-match {
font-weight: bold;
color: #2196F3;
}
.ali-real-price-popup .free-shipping-threshold {
font-style: italic;
color: #4CAF50;
margin-top: 8px;
}
`;
// Cache configuration
const CACHE_CONFIG = {
variants: { duration: 86400000, maxEntries: 100 }, // 24 hours
shipping: { duration: 86400000, maxEntries: 100 }, // 24 hours
context: { duration: 86400000, maxEntries: 10 } // 24 hours
};
// DOM Selectors
const SELECTORS = {
productCard: [
'.search-card-item', // Main search results
'.lq_b.io_it', // Alternative class combination
'.comet-v2-list-item', // Keep some old selectors as fallback
'.comet-v2-product-card',
'div[class*="ProductItem"]',
'div[class*="product-card"]',
'div[class*="card-out-wrapper"]'
].join(','),
price: [
'.lq_j3', // Main price container
'.lq_et', // Price wrapper
'.l5_k6',
'.U-S0j',
'div[class*="price-current"]',
'div[class*="PriceText"]',
'div[class*="productPrice"]',
'div[class*="price"]', // More generic fallbacks
'span[class*="price"]',
'[data-price]', // Data attribute
'[data-product-price]'
].join(','),
title: [
'.lq_jl', // Product title
'.lq_ae h3' // Title wrapper
].join(','),
shipping: [
'.lq_lv', // Shipping info
'.mi_l6[title*="shipping"]' // Shipping text
].join(','),
discount: [
'.lq_eu', // Discount percentage
'.lq_j4' // Original price
].join(','),
relatedItems: [
'.pdp-recommend-item',
'.recommend-item',
'.bundle-item',
'div[class*="RecommendItem"]'
].join(','),
variants: [
'.sku-property-item',
'.sku-property-text',
'.sku-property-image',
'div[class*="SkuItem"]'
].join(',')
};
// Utility functions
const utils = {
extractProductId(element) {
// Try multiple methods to find the product ID
const methods = [
// Method 1: New URL pattern (from your example)
() => {
const link = element.getAttribute('href');
if (!link) return null;
const match = link.match(/item\/(\d+)\.html/);
return match ? match[1] : null;
},
// Method 2: Legacy pattern
() => {
const link = element.querySelector('a[href*="/item/"]');
if (!link) return null;
const match = link.href.match(/\/(\d+)\.html/);
return match ? match[1] : null;
},
// Method 3: Data attribute
() => {
return element.getAttribute('data-product-id') ||
element.getAttribute('data-item-id') ||
element.getAttribute('data-id');
}
];
// Try each method until we find a product ID
for (const method of methods) {
const id = method();
if (id) {
log('Found product ID:', id, { productId: id });
return id;
}
}
log('Could not find product ID for element:', element);
return null;
},
formatPrice(value, currency = 'USD') {
return new Intl.NumberFormat('en-US', {
style: 'currency',
currency: currency
}).format(value);
},
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
},
// Get cookie by name
getCookie(name) {
const cookies = document.cookie.split(';');
for (let i = 0; i < cookies.length; i++) {
const cookie = cookies[i].trim();
if (cookie.startsWith(name + '=')) {
return cookie.substring(name.length + 1);
}
}
return '';
},
// Generate sign for API requests
generateSign(token, timestamp, appKey, data) {
const signStr = `${token}&${timestamp}&${appKey}&${data}`;
return md5(signStr);
}
};
// Cache Manager
class CacheManager {
constructor() {
this.cache = new Map();
// Load immediately, respecting the flag set during init
this.loadFromStorage();
}
async loadFromStorage() {
if (isCacheDisabled) {
log('Cache is disabled, skipping load from storage.');
this.cache.clear();
return;
}
try {
const storedCache = await GM.getValue('aliexpress_cache', null);
if (storedCache) {
const parsed = JSON.parse(storedCache);
// Only load non-expired entries
Object.entries(parsed).forEach(([key, entry]) => {
if (Date.now() <= entry.expiresAt) {
this.cache.set(key, entry);
}
});
log('Loaded cache from storage:', this.cache.size, 'entries');
}
} catch (error) {
log('Error loading cache from storage:', error);
}
}
async saveToStorage() {
if (isCacheDisabled) {
// log('Cache is disabled, skipping save to storage.'); // Maybe too noisy
return; // Don't save if cache is disabled
}
try {
// Convert Map to object for storage
const cacheObj = {};
this.cache.forEach((value, key) => {
cacheObj[key] = value;
});
await GM.setValue('aliexpress_cache', JSON.stringify(cacheObj));
log('Saved cache to storage:', Object.keys(cacheObj).length, 'entries');
} catch (error) {
log('Error saving cache to storage:', error);
}
}
async get(key) {
if (isCacheDisabled) return null; // Bypass cache if disabled
const entry = this.cache.get(key);
if (!entry) return null;
if (Date.now() > entry.expiresAt) {
this.cache.delete(key);
await this.saveToStorage();
return null;
}
return entry.data;
}
async set(key, data, config) {
if (isCacheDisabled) return; // Bypass cache if disabled
// Check if config is provided, otherwise use a default or skip
if (!config || !config.maxEntries || !config.duration) {
log('Cache config missing for key:', key, ' Using default or skipping.');
// Define a default config or return if you don't want to cache without specific config
config = CACHE_CONFIG.variants; // Example: Default to variants config
// Or simply return if caching requires explicit config
// return;
}
if (this.cache.size >= config.maxEntries) {
const oldestKey = this.cache.keys().next().value;
this.cache.delete(oldestKey);
}
this.cache.set(key, {
data,
timestamp: Date.now(),
expiresAt: Date.now() + config.duration
});
await this.saveToStorage();
}
async clear() {
this.cache.clear();
// Always allow clearing storage, even if cache is currently disabled
await GM.setValue('aliexpress_cache', '{}');
log('Cache cleared');
}
}
// Data Manager
class DataManager {
constructor() {
this.cache = new CacheManager();
this.tokenInitialized = false;
}
// Initialize token by making a simple request to AliExpress
async initializeToken() {
if (this.tokenInitialized) {
return;
}
log('Initializing token...');
// Check if token already exists
const token = utils.getCookie('_m_h5_tk');
if (token) {
log('Token already exists:', token.split('_')[0]);
this.tokenInitialized = true;
return;
}
// Make a request to the AliExpress homepage to get the token
try {
log('Making request to initialize token...');
return new Promise((resolve, reject) => {
GM.xmlHttpRequest({
method: 'GET',
url: 'https://www.aliexpress.us/',
headers: {
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
'accept-language': 'en-US,en;q=0.9',
'cache-control': 'no-cache',
'pragma': 'no-cache',
'sec-ch-ua': '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'none',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
},
onload: (response) => {
// Check if token was set in cookies
const newToken = utils.getCookie('_m_h5_tk');
if (newToken) {
log('Token initialized successfully:', newToken.split('_')[0]);
this.tokenInitialized = true;
resolve();
} else {
log('Failed to initialize token');
// Continue anyway
resolve();
}
},
onerror: (error) => {
log('Error initializing token:', error);
// Continue anyway
resolve();
}
});
});
} catch (error) {
log('Error in token initialization:', error);
// Continue anyway
}
}
async fetchProductData(productId) {
log('Fetching product data for ID:', productId, { productId });
const cacheKey = `product_${productId}`;
const cachedData = await this.cache.get(cacheKey);
if (cachedData) {
log(`[ARP_EnhanceFlow] [fetchProductData] Found cached data for product: ${productId}. Returning it.`, { productId });
return cachedData;
}
try {
// First get quick data from card
const card = document.querySelector(`a[href*="${productId}"]`);
let productData = null;
if (card) {
log('Found product card, extracting basic info');
const title = card.querySelector(SELECTORS.title)?.textContent?.trim() || '';
const priceContainer = card.querySelector(SELECTORS.price);
const priceInfo = this.extractPriceFromElement(priceContainer);
const shippingElement = card.querySelector(SELECTORS.shipping);
const shippingInfo = this.extractShippingFromElement(shippingElement);
const discountElement = card.querySelector(SELECTORS.discount);
const discountInfo = this.extractDiscountFromElement(discountElement);
productData = {
productId,
title,
variants: [{
id: 'default',
name: 'Default',
price: {
value: priceInfo.original || priceInfo.current,
formattedPrice: utils.formatPrice(priceInfo.original || priceInfo.current),
discountedValue: priceInfo.current,
discountedFormattedPrice: utils.formatPrice(priceInfo.current),
discount: discountInfo.percentage || ''
},
shipping: {
cost: shippingInfo.cost || 0,
formattedPrice: utils.formatPrice(shippingInfo.cost || 0),
freeThreshold: shippingInfo.freeThreshold
},
stock: 999,
isMainProduct: true
}]
};
}
// // Try to fetch full product data using the direct Taobao API
// try {
// log('Trying direct Aliexpress API call');
// const apiData = await this.fetchDirectAliExpressAPI(productId);
// if (apiData) {
// log('Successfully fetched data from direct Aliexpress API', { apiData});
// await this.cache.set(cacheKey, apiData, CACHE_CONFIG.variants);
// return apiData;
// }
// } catch (directApiError) {
// log(`Direct Taobao API call failed for productId ${productId}:`, directApiError);
// }
// Try to fetch full product data using the API
try {
// Get token from cookies
const token = utils.getCookie('_m_h5_tk')?.split('_')[0];
if (!token) {
log(`No token found in cookies, trying to fetch product page data for productId ${productId}`);
const pageData = await this.fetchDataFromProductPage(productId);
if (pageData) {
await this.cache.set(cacheKey, pageData, CACHE_CONFIG.variants);
return pageData;
}
if (productData) {
await this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
return productData;
}
throw new Error('No token found and no fallback data available');
}
log('Found token:', token);
// Prepare API request
const timestamp = Date.now();
const appKey = '12574478';
const apiVersion = '1.0';
// Construct the request data object
const requestData = {
productId,
_lang: 'en_US',
_currency: 'USD',
country: 'US',
province: '922867650000000000',
city: '922867656497000000',
channel: '',
pdp_ext_f: '{"order":"10","eval":"1"}',
sourceType: '',
clientType: 'pc',
ext: JSON.stringify({
site: 'usa',
crawler: false,
'x-m-biz-bx-region': '',
signedIn: true,
host: 'www.aliexpress.us'
})
};
// Convert request data to JSON string
const dataStr = JSON.stringify(requestData);
// Generate sign
const sign = utils.generateSign(token, timestamp, appKey, dataStr);
log('Generated sign:', sign);
// Construct the API URL with all parameters
const baseUrl = 'https://acs.aliexpress.us/h5/mtop.aliexpress.pdp.pc.query/1.0/';
const params = new URLSearchParams({
jsv: '2.5.1',
appKey,
t: timestamp,
sign,
api: 'mtop.aliexpress.pdp.pc.query',
type: 'originaljsonp',
v: apiVersion,
timeout: '15000',
dataType: 'originaljsonp',
callback: 'mtopjsonp1',
data: dataStr
});
const apiUrl = `${baseUrl}?${params.toString()}`;
log('Fetching from API URL:', apiUrl);
return new Promise((resolve, reject) => {
GM.xmlHttpRequest({
method: 'GET',
url: apiUrl,
headers: {
'accept': '*/*',
'accept-language': 'en-US,en;q=0.9',
'cache-control': 'no-cache',
'pragma': 'no-cache',
'referer': 'https://www.aliexpress.us/',
'sec-ch-ua': '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'script',
'sec-fetch-mode': 'no-cors',
'sec-fetch-site': 'same-site',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
},
withCredentials: true, // Important: send cookies with the request
onload: (response) => {
try {
// log(`Received raw API response: ${response.responseText}`);
// Extract JSON from JSONP response
const jsonMatch = response.responseText.match(/mtopjsonp1\((.*)\)/);
if (!jsonMatch) {
throw new Error('Invalid JSONP response format');
}
const apiResponseData = JSON.parse(jsonMatch[1]);
log('Parsed API response:', {productId, apiResponseData});
if (apiResponseData.ret && apiResponseData.ret[0]?.startsWith('FAIL_')) {
log('API returned error:', apiResponseData.ret[0]);
if (apiResponseData.ret[0].includes('FAIL_SYS_ILLEGAL_ACCESS')) {
throw new Error(apiResponseData.ret[0]); // This will trigger backoff
}
// Try to fetch product page data as fallback
this.fetchDataFromProductPage(productId).then(pageData => {
if (pageData) {
this.cache.set(cacheKey, pageData, CACHE_CONFIG.variants);
resolve(pageData);
return;
}
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(new Error(`API Error: ${apiResponseData.ret[0]}`));
}
}).catch(err => {
log('Error fetching product page data:', err);
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(new Error(`API Error: ${apiResponseData.ret[0]}`));
}
});
return;
}
const fullProductData = this.parseProductData(apiResponseData);
if (productData) {
fullProductData.variants = fullProductData.variants.length > 0
? fullProductData.variants
: productData.variants;
fullProductData.title = fullProductData.title || productData.title;
}
this.cache.set(cacheKey, fullProductData, CACHE_CONFIG.variants);
resolve(fullProductData);
} catch (error) {
log('Error processing API response:', error);
// Try to fetch product page data as fallback
this.fetchDataFromProductPage(productId).then(pageData => {
if (pageData) {
this.cache.set(cacheKey, pageData, CACHE_CONFIG.variants);
resolve(pageData);
return;
}
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(error);
}
}).catch(err => {
log('Error fetching product page data:', err);
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(error);
}
});
}
},
onerror: (error) => {
log('Error fetching API data:', error);
// Try to fetch product page data as fallback
this.fetchDataFromProductPage(productId).then(pageData => {
if (pageData) {
this.cache.set(cacheKey, pageData, CACHE_CONFIG.variants);
resolve(pageData);
return;
}
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(error);
}
}).catch(err => {
log('Error fetching product page data:', err);
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
resolve(productData);
} else {
reject(error);
}
});
}
});
});
} catch (apiError) {
log('API request failed, trying to fetch product page data:', apiError);
try {
const pageData = await this.fetchDataFromProductPage(productId);
if (pageData) {
this.cache.set(cacheKey, pageData, CACHE_CONFIG.variants);
return pageData;
}
} catch (pageError) {
log('Error fetching product page data:', pageError);
}
if (productData) {
this.cache.set(cacheKey, productData, CACHE_CONFIG.variants);
return productData;
}
throw apiError;
}
} catch (error) {
log('Error in fetchProductData:', error);
throw error;
}
}
// Direct Taobao API call based on the shared resources
async fetchDirectAliExpressAPI(productId) {
log('Making direct Taobao API call for product ID:', productId);
try {
// Based on the shared resources, we'll use a different approach
// This is based on the GitHub repo and blog post you shared
// Prepare API request
const timestamp = Date.now();
const appKey = '12574478';
// Construct the request data object
const requestData = {
itemId: productId,
language: 'en',
currency: 'USD',
region: 'US',
locale: 'en_US',
site: 'usa'
};
// Convert request data to JSON string
const dataStr = JSON.stringify(requestData);
// Construct the API URL
const apiUrl = `https://www.aliexpress.us/aer-api/v1/product/detail?productId=${productId}`;
log('Fetching from direct API URL:', apiUrl);
return new Promise((resolve, reject) => {
GM.xmlHttpRequest({
method: 'GET',
url: apiUrl,
headers: {
'accept': 'application/json, text/plain, */*',
'accept-language': 'en-US,en;q=0.9',
'cache-control': 'no-cache',
'pragma': 'no-cache',
'referer': `https://www.aliexpress.us/item/${productId}.html`,
'sec-ch-ua': '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-origin',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
},
withCredentials: true,
onload: (response) => {
try {
log('Received direct API response');
// if url is 404.html, we didn't find the product
if (response.finalUrl.includes('404.html')) {
log(`product ${productId} not found`);
resolve(null);
return;
}
// Parse JSON response
const data = JSON.parse(response.responseText);
log('Parsed direct API response:', data);
if (!data.data || data.code !== 200) {
log('Direct API returned error:', data.message || 'Unknown error');
resolve(null);
return;
}
// Parse the product data
const productData = this.parseDirectAPIResponse(data, productId);
if (productData) {
log('Successfully parsed direct API response');
resolve(productData);
} else {
log('Failed to parse direct API response');
resolve(null);
}
} catch (error) {
log('Error processing direct API response:', error);
resolve(null);
}
},
onerror: (error) => {
log('Error fetching direct API data:', error);
resolve(null);
}
});
});
} catch (error) {
log('Error in fetchDirectTaobaoAPI:', error);
return null;
}
}
// Parse the direct API response
parseDirectAPIResponse(data, productId) {
try {
log('Parsing direct API response', { productId });
const productDetail = data.data || {};
// Extract title
const title = productDetail.productTitle || productDetail.title || '';
// Extract variants
let variants = [];
// Try to extract variants from skuModule
const skuModule = productDetail.skuModule || {};
const skuPriceModule = productDetail.priceModule || {};
const shippingModule = productDetail.shippingModule || {};
if (skuModule.skuPriceList || skuModule.skuList) {
const skuList = skuModule.skuPriceList || skuModule.skuList || [];
variants = skuList.map(sku => {
const skuId = sku.skuId || sku.id;
const skuName = this.extractSkuName(sku, skuModule) || 'Default';
const priceInfo = sku.skuVal || sku;
// Extract shipping info
const shippingInfo = this.extractShippingInfoFromModule(shippingModule, productId);
return {
id: skuId,
name: skuName,
price: {
value: priceInfo.skuAmount?.value || priceInfo.skuPrice || 0,
formattedPrice: utils.formatPrice(priceInfo.skuAmount?.value || priceInfo.skuPrice || 0),
discountedValue: priceInfo.skuActivityAmount?.value || priceInfo.actSkuPrice || priceInfo.skuPrice || 0,
discountedFormattedPrice: utils.formatPrice(priceInfo.skuActivityAmount?.value || priceInfo.actSkuPrice || priceInfo.skuPrice || 0),
discount: priceInfo.discount || ''
},
shipping: shippingInfo,
stock: sku.skuVal?.availQuantity || sku.inventory || 999,
isMainProduct: this.isMainProductBySku(sku)
};
});
}
// If no variants found, create a default one
if (variants.length === 0) {
const priceInfo = skuPriceModule.formatedActivityPrice || skuPriceModule.formatedPrice || '';
const priceValue = parseFloat(priceInfo.replace(/[^\d.]/g, '')) || 0;
// Extract shipping info
const shippingInfo = this.extractShippingInfoFromModule(shippingModule, productId);
variants = [{
id: 'default',
name: 'Default',
price: {
value: priceValue,
formattedPrice: utils.formatPrice(priceValue),
discountedValue: priceValue,
discountedFormattedPrice: utils.formatPrice(priceValue),
discount: skuPriceModule.discount || ''
},
shipping: shippingInfo,
stock: 999,
isMainProduct: true
}];
}
return {
productId,
title,
variants
};
} catch (error) {
log('Error parsing direct API response:', error, { productId });
return null;
}
}
// Extract SKU name from SKU object
extractSkuName(sku, skuModule) {
try {
// Try to extract name from skuAttr (format: "14:350685#1m")
if (sku.skuAttr) {
const parts = sku.skuAttr.split('#');
if (parts.length > 1) {
return parts[1];
}
}
// Try to extract name from propPath
if (sku.propPath) {
const propIds = sku.propPath.split(';').map(p => p.split(':')[1]);
// Find property values
const propNames = [];
const props = skuModule.props || [];
for (const prop of props) {
const values = prop.values || [];
for (const value of values) {
if (propIds.includes(value.id)) {
propNames.push(value.name);
}
}
}
if (propNames.length > 0) {
return propNames.join(' ');
}
}
return 'Default';
} catch (error) {
log('Error extracting SKU name:', error);
return 'Default';
}
}
// Extract shipping info from shipping module
extractShippingInfoFromModule(shippingModule, productId) {
try {
log('Raw shipping module data:', shippingModule, { productId });
const defaultShipping = {
cost: 0,
formattedPrice: '$0.00',
freeThreshold: null
};
if (!shippingModule) {
return defaultShipping;
}
// Find shipping cost
const shippingOptions = shippingModule.freightCalculateInfo?.freight || [];
if (shippingOptions.length === 0) {
return defaultShipping;
}
// Get the cheapest shipping option
const cheapestOption = shippingOptions.reduce((min, option) => {
const cost = option.freightAmount?.value || 0;
return cost < min.cost ? { cost, option } : min;
}, { cost: Infinity, option: null });
if (cheapestOption.option) {
const cost = cheapestOption.cost;
// Check for free shipping threshold
let freeThreshold = null;
if (shippingModule.freightCalculateInfo?.freeShippingText) {
const thresholdMatch = shippingModule.freightCalculateInfo.freeShippingText.match(/\$(\d+(\.\d{2})?)/);
if (thresholdMatch) {
freeThreshold = parseFloat(thresholdMatch[1]);
}
}
return {
cost,
formattedPrice: utils.formatPrice(cost),
freeThreshold
};
}
return defaultShipping;
} catch (error) {
log('Error extracting shipping info:', error);
return {
cost: 0,
formattedPrice: '$0.00',
freeThreshold: null
};
}
}
extractPriceFromElement(element) {
if (!element) return { current: 0, original: 0 };
try {
// Extract current price
const currentPriceText = element.textContent.match(/\$[\d,.]+/)?.[0] || '0';
const currentPrice = parseFloat(currentPriceText.replace(/[$,]/g, ''));
// Extract original price if available (crossed out price)
const originalPriceElement = element.querySelector('.lq_j4');
const originalPriceText = originalPriceElement?.textContent.match(/\$[\d,.]+/)?.[0] || currentPriceText;
const originalPrice = parseFloat(originalPriceText.replace(/[$,]/g, ''));
return {
current: currentPrice,
original: originalPrice
};
} catch (error) {
log('Error extracting price:', error);
return { current: 0, original: 0 };
}
}
extractShippingFromElement(element) {
if (!element) return { cost: 0, freeThreshold: null };
try {
const text = element.textContent;
const freeThresholdMatch = text.match(/Free shipping over \$(\d+(\.\d{2})?)/i);
const shippingCostMatch = text.match(/Shipping: \$(\d+(\.\d{2})?)/i);
return {
cost: shippingCostMatch ? parseFloat(shippingCostMatch[1]) : 0,
freeThreshold: freeThresholdMatch ? parseFloat(freeThresholdMatch[1]) : null
};
} catch (error) {
log('Error extracting shipping:', error);
return { cost: 0, freeThreshold: null };
}
}
extractDiscountFromElement(element) {
if (!element) return { percentage: '' };
try {
const text = element.textContent;
const percentageMatch = text.match(/-(\d+)%/);
return {
percentage: percentageMatch ? `-${percentageMatch[1]}%` : ''
};
} catch (error) {
log('Error extracting discount:', error);
return { percentage: '' };
}
}
createSingleVariant(result, productId) {
// Extract price from the page data
const priceInfo = result.priceComponent || result.price || {};
// Extract shipping from the new path
const shippingData = result.SHIPPING || {};
const deliveryLayout = shippingData.deliveryLayoutInfo?.[0] || {};
const shippingBizData = deliveryLayout.bizData || {};
// Get the price values
const originalPrice = this.extractDefaultPrice(result);
const discountedPrice = priceInfo.activityPrice || priceInfo.discountPrice || originalPrice;
// Extract base shipping info
const baseShippingInfo = this.extractShippingInfo(shippingBizData, productId);
return [{ // Return as an array containing the single variant object
id: 'default',
name: 'Default',
price: {
value: originalPrice,
formattedPrice: utils.formatPrice(originalPrice),
discountedValue: discountedPrice,
discountedFormattedPrice: utils.formatPrice(discountedPrice),
discount: priceInfo.discount || ''
},
shipping: baseShippingInfo, // Use the extracted base info
stock: 999,
isMainProduct: true
}];
}
parseProductData(data) {
log('Parsing data:', data);
const productId = data.data?.result?.productId || ''; // Extract productId for logging
// Handle different API response structures
const result = data.data?.result || data.data || {};
log('Result object:', result, { productId });
// Handle error responses
if (data.ret && data.ret[0]?.startsWith('FAIL_')) {
log('API returned error:', data.ret[0], { productId });
return {
productId: productId,
title: result.title || '',
variants: [this.createDefaultVariant(result)]
};
}
// Extract basic product info
const productInfo = {
productId: productId,
title: result.title || '',
};
// Extract variants
let variants = [];
try {
// Get SKU and price data from the correct paths
const skuPaths = result.SKU?.skuPaths || [];
const priceMap = result.PRICE?.skuIdStrPriceInfoMap || {};
// Extract shipping info from the new path
const shippingData = result.SHIPPING || {};
const deliveryLayout = shippingData.deliveryLayoutInfo?.[0] || {};
const shippingBizData = deliveryLayout.bizData || {};
const deliveryGuarantee = shippingData.DELIVERY_GUARANTEE_SERVICE || {};
// Note: Free shipping text info might be nested differently, adjust if needed
const freeShippingTextInfo = {}; // Placeholder
if (skuPaths.length > 0) {
variants = skuPaths.map(sku => {
const skuId = sku.skuIdStr || sku.skuId;
const priceInfo = priceMap[skuId] || {};
// Base variant data without shipping
return {
id: skuId,
name: this.getSkuName(sku),
price: {
value: priceInfo.originalPrice?.value || 0,
formattedPrice: priceInfo.originalPrice?.formatedAmount || '$0.00',
discountedValue: this.extractPriceValue(priceInfo.salePriceString) || priceInfo.originalPrice?.value || 0,
discountedFormattedPrice: priceInfo.salePriceString || priceInfo.originalPrice?.formatedAmount || '$0.00',
discount: priceInfo.discount || ''
},
stock: sku.skuStock || sku.availQuantity || 999,
isMainProduct: this.isMainProductBySku(sku)
};
});
} else {
// Single variant case
// Pass productId to createSingleVariant
variants = [this.createSingleVariant(result, productId)];
}
// Extract base shipping info ONCE
const baseShippingInfo = this.extractShippingInfo(shippingBizData, productId);
// Add shipping info (cost, guarantee, etc.) to all variants
variants = this.addShippingInfo(variants, baseShippingInfo, deliveryGuarantee, freeShippingTextInfo, productId);
} catch (error) {
log('Error parsing variants:', error, { productId });
variants = [this.createDefaultVariant(result)];
}
return {
...productInfo,
variants: variants.length > 0 ? variants : [this.createDefaultVariant(result, productId)]
};
}
getSkuName(sku) {
// Extract name from skuAttr (format: "14:350685#1m")
const skuAttr = sku.skuAttr || '';
const parts = skuAttr.split('#');
return parts[1] || 'Default';
}
isMainProductBySku(sku) {
const name = (sku.skuAttr || '').toLowerCase();
return !this.isAccessory(name);
}
extractPriceValue(priceString) {
if (!priceString) return 0;
const match = priceString.match(/[\d,.]+/);
return match ? parseFloat(match[0].replace(/,/g, '')) : 0;
}
createDefaultVariant(result, productId) {
// Create a default variant when no variant info is available
const defaultPrice = this.extractDefaultPrice(result);
return {
id: 'default',
name: 'Default',
price: {
value: defaultPrice,
formattedPrice: utils.formatPrice(defaultPrice),
discountedValue: defaultPrice,
discountedFormattedPrice: utils.formatPrice(defaultPrice),
discount: ''
},
shipping: {
cost: 0,
formattedPrice: '$0.00',
freeThreshold: null
},
stock: 999,
isMainProduct: true
};
}
extractDefaultPrice(result) {
// Try various paths to find the price
const productId = result?.productId || ''; // Get productId if available
const paths = [
result.priceComponent?.originalPrice,
result.price?.originalPrice?.value,
result.price?.minPrice,
result.PRICE?.originalPrice?.value,
result.PRICE?.minPrice
];
for (const price of paths) {
if (typeof price === 'number' && !isNaN(price)) {
return price;
}
}
log('Could not extract default price from result object', { productId, result });
return 0;
}
extractShippingInfo(shippingBizData, productId) {
log('Raw shippingBizData object:', shippingBizData, { productId }); // Log the full object
const hasChoiceFreeShipping = shippingBizData?.choiceFreeShipping === 'yes';
log(`[extractShippingInfo] choiceFreeShipping status for ${productId}:`, hasChoiceFreeShipping);
return {
cost: shippingBizData?.displayAmount || 0,
// Use formattedAmount if available, otherwise format the cost
formattedPrice: shippingBizData?.formattedAmount || utils.formatPrice(shippingBizData?.displayAmount || 0),
// Free threshold logic might need revisiting based on bizData structure - removed for now
freeThreshold: null, // Keep null for now, threshold *value* extraction needs review
hasChoiceFreeShipping: hasChoiceFreeShipping // Add the boolean status
};
}
extractFreeShippingThreshold(shipping) {
// This function needs to be re-evaluated based on the new API structure.
// It's currently not used because extractShippingInfo sets freeThreshold to null.
log('extractFreeShippingThreshold called, but logic needs review based on SHIPPING.deliveryLayoutInfo structure', { shipping });
return null;
}
addShippingInfo(variants, baseShippingInfo, deliveryGuarantee, freeShippingTextInfo, productId) {
// baseShippingInfo is the object returned by extractShippingInfo
// deliveryGuarantee is the result.DELIVERY_GUARANTEE_SERVICE object
// freeShippingTextInfo is the (potentially empty) free shipping text component
return variants.map(variant => ({
...variant,
shipping: {
...baseShippingInfo, // Contains cost, formattedPrice, freeThreshold (currently null)
guaranteedDays: deliveryGuarantee?.subContents?.[3]?.content?.match(/\d+/)?.[0] || null,
freeShippingText: freeShippingTextInfo?.mainText || null
// TODO: Re-evaluate freeThreshold extraction if needed
}
}));
}
isAccessory(name) {
const accessoryKeywords = [
'case', 'cover', 'protector', 'cable', 'adapter', 'charger',
'holder', 'stand', 'accessory', 'kit', 'pedal', 'spare',
'replacement', 'tool', 'bag', 'box'
];
return accessoryKeywords.some(keyword => name.includes(keyword));
}
// Fetch product data directly from the product page HTML
async fetchDataFromProductPage(productId) {
log('Fetching product page data for ID:', productId);
// Add log to indicate fallback
log(`Falling back to fetching data directly from product page HTML for productId: ${productId}`, { productId });
try {
const productUrl = `https://www.aliexpress.us/item/${productId}.html`;
log('Fetching product page:', productUrl);
return new Promise((resolve, reject) => {
GM.xmlHttpRequest({
method: 'GET',
url: productUrl,
headers: {
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
'accept-language': 'en-US,en;q=0.9',
'cache-control': 'no-cache',
'pragma': 'no-cache',
'sec-ch-ua': '"Chromium";v="134", "Not:A-Brand";v="24", "Google Chrome";v="134"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'none',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
},
onload: (response) => {
try {
log('Received product page response');
// Extract product data from HTML
const productData = this.extractProductDataFromHTML(response.responseText, productId);
if (productData) {
log('Successfully extracted product data from HTML');
resolve(productData);
} else {
log('Failed to extract product data from HTML');
resolve(null);
}
} catch (error) {
log('Error processing product page response:', error);
resolve(null);
}
},
onerror: (error) => {
log('Error fetching product page:', error);
resolve(null);
}
});
});
} catch (error) {
log('Error in fetchProductPageData:', error);
return null;
}
}
// Extract product data from HTML
extractProductDataFromHTML(html, productId) {
try {
log('Extracting product data from HTML');
// Create a temporary DOM element to parse the HTML
const parser = new DOMParser();
const doc = parser.parseFromString(html, 'text/html');
// Look for the product data in the page
const scriptElements = Array.from(doc.querySelectorAll('script'));
// Find the script that contains the product data
let productData = null;
// Method 1: Look for runParams.data
for (const script of scriptElements) {
const content = script.textContent;
if (content.includes('runParams.data')) {
const match = content.match(/runParams\.data\s*=\s*({.*?});/s);
if (match && match[1]) {
try {
productData = JSON.parse(match[1]);
log('Found product data in runParams.data');
break;
} catch (e) {
log('Error parsing runParams.data:', e);
}
}
}
}
// Method 2: Look for window.__INITIAL_STATE__
if (!productData) {
for (const script of scriptElements) {
const content = script.textContent;
if (content.includes('window.__INITIAL_STATE__')) {
const match = content.match(/window\.__INITIAL_STATE__\s*=\s*({.*?});/s);
if (match && match[1]) {
try {
const state = JSON.parse(match[1]);
productData = state.productDetail?.data;
log('Found product data in window.__INITIAL_STATE__');
break;
} catch (e) {
log('Error parsing window.__INITIAL_STATE__:', e);
}
}
}
}
}
// Method 3: Look for data-pdp-json
if (!productData) {
const jsonElement = doc.querySelector('[data-pdp-json]');
if (jsonElement) {
try {
productData = JSON.parse(jsonElement.getAttribute('data-pdp-json'));
log('Found product data in data-pdp-json attribute');
} catch (e) {
log('Error parsing data-pdp-json:', e);
}
}
}
// Method 4: Look for window.runParams
if (!productData) {
for (const script of scriptElements) {
const content = script.textContent;
if (content.includes('window.runParams')) {
const match = content.match(/window\.runParams\s*=\s*({.*?});/s);
if (match && match[1]) {
try {
const runParams = JSON.parse(match[1]);
productData = runParams.data;
log('Found product data in window.runParams');
break;
} catch (e) {
log('Error parsing window.runParams:', e);
}
}
}
}
}
if (!productData) {
log('Could not find product data in HTML');
return null;
}
// Extract title
const title = productData.title || productData.subject ||
doc.querySelector('h1')?.textContent?.trim() || '';
// Extract variants
let variants = [];
// Try to extract variants from skuModule
const skuModule = productData.skuModule || productData.skuInfo || {};
const skuPriceModule = productData.priceModule || productData.priceInfo || {};
if (skuModule.skuPriceList || skuModule.skuList) {
const skuList = skuModule.skuPriceList || skuModule.skuList || [];
variants = skuList.map(sku => {
const skuId = sku.skuId || sku.id;
const skuName = sku.skuAttr?.split('#')[1] || 'Default';
const priceInfo = sku.skuVal || sku;
return {
id: skuId,
name: skuName,
price: {
value: priceInfo.skuAmount?.value || priceInfo.skuPrice || 0,
formattedPrice: utils.formatPrice(priceInfo.skuAmount?.value || priceInfo.skuPrice || 0),
discountedValue: priceInfo.skuActivityAmount?.value || priceInfo.actSkuPrice || priceInfo.skuPrice || 0,
discountedFormattedPrice: utils.formatPrice(priceInfo.skuActivityAmount?.value || priceInfo.actSkuPrice || priceInfo.skuPrice || 0),
discount: priceInfo.discount || ''
},
shipping: {
cost: 0, // We don't have shipping info from HTML
formattedPrice: '$0.00',
freeThreshold: null
},
stock: sku.skuVal?.availQuantity || sku.inventory || 999,
isMainProduct: true
};
});
}
// If no variants found, create a default one
if (variants.length === 0) {
const priceInfo = skuPriceModule.formatedActivityPrice || skuPriceModule.formatedPrice || '';
const priceValue = parseFloat(priceInfo.replace(/[^\d.]/g, '')) || 0;
variants = [{
id: 'default',
name: 'Default',
price: {
value: priceValue,
formattedPrice: utils.formatPrice(priceValue),
discountedValue: priceValue,
discountedFormattedPrice: utils.formatPrice(priceValue),
discount: skuPriceModule.discount || ''
},
shipping: {
cost: 0,
formattedPrice: '$0.00',
freeThreshold: null
},
stock: 999,
isMainProduct: true
}];
}
return {
productId,
title,
variants
};
} catch (error) {
log('Error extracting product data from HTML:', error);
return null;
}
}
}
// Price Context Calculator
class PriceContextCalculator {
calculatePageContext(productCards) {
const prices = [];
for (const card of productCards) {
const priceElement = card.querySelector(SELECTORS.price);
if (priceElement) {
const price = this.extractPriceValue(priceElement.textContent);
if (price) prices.push(price);
}
}
if (prices.length === 0) return null;
prices.sort((a, b) => a - b);
const median = this.calculateMedian(prices);
const threshold = median * 0.3;
return {
median,
lowerBound: median - threshold,
upperBound: median + threshold,
distribution: this.calculateDistribution(prices)
};
}
calculateMedian(prices) {
const mid = Math.floor(prices.length / 2);
return prices.length % 2 === 0
? (prices[mid - 1] + prices[mid]) / 2
: prices[mid];
}
calculateDistribution(prices) {
return {
min: Math.min(...prices),
max: Math.max(...prices),
clusters: this.findPriceClusters(prices)
};
}
findPriceClusters(prices) {
// Simple clustering based on price ranges
const range = prices[prices.length - 1] - prices[0];
const step = range / 5;
const clusters = [];
for (let i = 0; i < 5; i++) {
const min = prices[0] + (step * i);
const max = prices[0] + (step * (i + 1));
const clusterPrices = prices.filter(p => p >= min && p < max);
if (clusterPrices.length > 0) {
clusters.push({
centerPrice: (min + max) / 2,
count: clusterPrices.length,
variance: this.calculateVariance(clusterPrices)
});
}
}
return clusters;
}
calculateVariance(prices) {
const mean = prices.reduce((a, b) => a + b) / prices.length;
return Math.sqrt(
prices.reduce((sq, n) => sq + Math.pow(n - mean, 2), 0) / prices.length
);
}
findBestMatchingVariant(variants, context) {
if (!context || variants.length === 0) return variants[0];
return variants
.map(variant => ({
...variant,
score: this.calculateVariantScore(variant, context)
}))
.sort((a, b) => b.score - a.score)[0];
}
calculateVariantScore(variant, context) {
const { median, lowerBound, upperBound } = context;
const price = variant.price.discountedValue;
const distanceScore = 1 / (Math.abs(price - median) + 1);
const inRange = price >= lowerBound && price <= upperBound ? 1.5 : 0.5;
const productTypeMultiplier = variant.isMainProduct ? 1.3 : 0.7;
return distanceScore * inRange * productTypeMultiplier;
}
extractPriceValue(text) {
const match = text.match(/[\d,.]+/);
return match ? parseFloat(match[0].replace(/,/g, '')) : 0;
}
}
// DOM Enhancement Manager
class DOMEnhancer {
constructor(dataManager, priceContextCalculator) {
this.dataManager = dataManager;
this.priceContextCalculator = priceContextCalculator;
this.setupIntersectionObserver();
this.pendingEnhancements = new Set();
this.processedCards = new WeakSet(); // Track processed cards
}
setupIntersectionObserver() {
this.observer = new IntersectionObserver(
(entries) => {
entries.forEach(entry => {
if (entry.isIntersecting) {
const productCard = entry.target;
const productId = utils.extractProductId(productCard);
if (productId) {
this.pendingEnhancements.add(productId);
this.enhanceProductCard(productCard, productId);
this.observer.unobserve(productCard);
}
}
});
},
{ rootMargin: '200px' }
);
}
async enhanceProductCard(card, productId) {
// Check if we've already processed this card
log(`[ARP_EnhanceFlow] [enhanceProductCard START] Processing card ${productId}`, { productId });
if (this.processedCards.has(card)) {
log('Card already processed:', productId, { productId });
this.pendingEnhancements.delete(productId);
loadingManager.itemComplete();
return;
}
log('Enhancing product card:', productId, { productId });
let priceElement = null;
try {
// Try multiple strategies to find the price element
const priceSelectors = SELECTORS.price.split(',');
// Log all potential price elements for debugging
log('Searching for price element with selectors:', priceSelectors, { productId });
for (const selector of priceSelectors) {
const elements = card.querySelectorAll(selector.trim());
if (elements.length > 0) {
// Take the most specific (deepest) price element
priceElement = Array.from(elements).reduce((best, current) => {
const bestDepth = this.getElementDepth(best);
const currentDepth = this.getElementDepth(current);
return currentDepth > bestDepth ? current : best;
});
log('Found price element using selector:', selector, {
productId,
elementHtml: priceElement.outerHTML,
elementClass: priceElement.className
});
break;
}
}
if (!priceElement) {
// If still not found, try searching deeper in the card
log('No price element found with selectors, trying text pattern search', { productId });
const allElements = card.getElementsByTagName('*');
for (const element of allElements) {
const text = element.textContent;
// Look for price-like patterns (e.g., $XX.XX)
if (/\$\d+(\.\d{2})?/.test(text) && !element.querySelector('*')) {
priceElement = element;
log('Found price element using text pattern:', {
productId,
text,
elementHtml: element.outerHTML,
elementClass: element.className
});
break;
}
}
}
if (!priceElement) {
log('No price element found for product:', productId, {
productId,
cardHtml: card.outerHTML
});
this.pendingEnhancements.delete(productId);
loadingManager.itemComplete();
return;
}
// Verify the element is still in the DOM
if (!document.contains(priceElement)) {
log('Price element is no longer in the DOM:', {
productId,
elementHtml: priceElement.outerHTML
});
this.pendingEnhancements.delete(productId);
loadingManager.itemComplete();
return;
}
// Mark the card as being processed
this.processedCards.add(card);
// Fetch data with rate limiting
const productData = await rateLimiter.executeWithBackoff(async () => {
return await this.dataManager.fetchProductData(productId);
});
log(`[ARP_EnhanceFlow] [enhanceProductCard] Got productData (cached or fetched) for ${productId}`, { productId });
// Verify element is still valid after async operation
if (!document.contains(priceElement)) {
log('Price element was removed during async operation', { productId });
this.pendingEnhancements.delete(productId);
loadingManager.itemComplete();
return;
}
log('Received product data for enhancement:', productData, { productId });
const context = this.priceContextCalculator.calculatePageContext(
Array.from(document.querySelectorAll(SELECTORS.productCard))
);
const bestVariant = this.priceContextCalculator.findBestMatchingVariant(
productData.variants,
context
);
this.updatePriceDisplay(priceElement, bestVariant, productData, context, productId);
} catch (error) {
log('Error enhancing product card:', productId, error, { productId });
if (priceElement && document.contains(priceElement)) {
try {
// Add error class instead of replacing completely
priceElement.classList.add('ali-real-price-error');
priceElement.textContent = 'Price data unavailable';
} catch (displayError) {
log('Error showing error state:', displayError, { productId });
}
}
} finally {
// *** This SHOULD always run ***
log(`[ARP_EnhanceFlow] [enhanceProductCard finally] Reached finally block for ${productId}`, { productId });
this.pendingEnhancements.delete(productId);
loadingManager.itemComplete(); // This is the call that updates the counter
}
}
updatePriceDisplay(element, bestVariant, productData, context, productId) {
if (!element) {
log('Cannot update price display - element is null');
return;
}
if (!element.parentNode) {
log('Cannot update price display - element has no parent', {
elementHtml: element.outerHTML,
elementClass: element.className,
elementId: element.id
});
return;
}
// Get total price range (includes shipping)
const priceRange = this.getPriceRange(productData.variants, productId);
const displayOptions = {
showShipping: true, // Keep flag for potential future use, but won't add text now
showMedianIndicator: true,
showPriceRange: true,
showDistributionGraph: true
};
// Start with the total price of the best matching variant
const bestVariantTotal = (bestVariant.price?.discountedValue || 0) + (bestVariant.shipping?.cost || 0);
let displayText = utils.formatPrice(bestVariantTotal);
if (displayOptions.showPriceRange && priceRange.min !== priceRange.max) {
// Display the total price range
displayText = `${utils.formatPrice(priceRange.min)} - ${utils.formatPrice(priceRange.max)}`;
}
// Add note about shipping being included only if:
// 1. The base shipping cost is > 0
// 2. There is NO "Choice Free Shipping" option available
if (bestVariant.shipping?.cost > 0 && !bestVariant.shipping?.hasChoiceFreeShipping) {
log(`Adding '(including shipping)' for ${productId} because cost is ${bestVariant.shipping?.cost} and hasChoiceFreeShipping is ${bestVariant.shipping?.hasChoiceFreeShipping}`);
displayText += ' (including shipping)';
} else {
log(`NOT adding '(including shipping)' for ${productId} because cost is ${bestVariant.shipping?.cost} and hasChoiceFreeShipping is ${bestVariant.shipping?.hasChoiceFreeShipping}`);
}
if (displayOptions.showMedianIndicator) {
displayText += ' ⊙';
}
// Instead of replacing the element, try to modify it in place first
try {
element.className = 'ali-real-price-range ' + element.className;
element.innerHTML = displayText;
// Add hover events for variant popup
const card = element.closest(SELECTORS.productCard);
if (card) {
let popupTimeout;
element.addEventListener('mouseenter', () => {
log('mouseenter', {productId});
popupTimeout = setTimeout(() => {
this.showVariantPopup(card, productData.variants, bestVariant, context, productId);
}, 200); // Small delay to prevent flicker
});
log('mouseenter event listener added', {productId});
element.addEventListener('mouseleave', () => {
clearTimeout(popupTimeout);
setTimeout(() => {
this.hideVariantPopup(card, productId);
}, 200); // Small delay to allow moving mouse to popup
});
} else {
log('no card found for when establishing hover events', {productId});
}
if (displayOptions.showDistributionGraph) {
this.addPriceDistributionGraph(element, bestVariant, priceRange, productId);
}
return;
} catch (modifyError) {
log('Failed to modify element in place:', modifyError);
}
// If modifying in place fails, try replacement
try {
const container = document.createElement('div');
container.className = 'ali-real-price-range';
container.innerHTML = displayText;
// Add hover events for variant popup
const card = element.closest(SELECTORS.productCard);
if (card) {
let popupTimeout;
container.addEventListener('mouseenter', () => {
log('mouseenter (container)', {productId});
popupTimeout = setTimeout(() => {
this.showVariantPopup(card, productData.variants, bestVariant, context, productId);
}, 200); // Small delay to prevent flicker
});
container.addEventListener('mouseleave', () => {
clearTimeout(popupTimeout);
setTimeout(() => {
this.hideVariantPopup(card, productId);
}, 200); // Small delay to allow moving mouse to popup
});
}
if (displayOptions.showDistributionGraph) {
this.addPriceDistributionGraph(container, bestVariant, priceRange, productId);
}
element.parentNode.replaceChild(container, element);
} catch (error) {
log('Error replacing price element:', error, {
elementHtml: element.outerHTML,
parentHtml: element.parentNode?.outerHTML
});
}
}
showVariantPopup(card, variants, bestVariant, context, productId) {
log('Showing variant popup', { productId });
// Remove any existing popup first
this.hideVariantPopup(card, productId, false); // Don't log removal here
const popup = document.createElement('div');
popup.className = 'ali-real-price-popup';
const variantList = document.createElement('ul');
const sortedVariants = [...variants].sort((a, b) => {
const totalA = a.price.discountedValue + a.shipping.cost;
const totalB = b.price.discountedValue + b.shipping.cost;
return totalA - totalB;
});
for (const variant of sortedVariants) {
const variantItem = document.createElement('li');
const isMedianMatch = variant.id === bestVariant.id;
variantItem.innerHTML = `
${isMedianMatch ? '⊙ ' : '• '}
${variant.name} ${variant.price.discountedFormattedPrice}
${variant.shipping.cost > 0 ? `+ ${variant.shipping.formattedPrice} shipping` : ''}
= ${utils.formatPrice(variant.price.discountedValue + variant.shipping.cost)} total
`;
if (isMedianMatch) {
variantItem.classList.add('median-match');
}
variantList.appendChild(variantItem);
}
popup.appendChild(variantList);
const freeShippingThreshold = this.getFreeShippingThreshold(variants, productId);
if (freeShippingThreshold) {
const thresholdInfo = document.createElement('div');
thresholdInfo.className = 'free-shipping-threshold';
thresholdInfo.textContent = `Free shipping over ${utils.formatPrice(freeShippingThreshold)}`;
popup.appendChild(thresholdInfo);
}
this.positionPopup(popup, card);
card.appendChild(popup);
}
hideVariantPopup(card, productId, shouldLog = true) {
const popup = card.querySelector('.ali-real-price-popup');
if (popup) {
if (shouldLog) log('Hiding variant popup', { productId });
popup.remove();
}
}
positionPopup(popup, card) {
const cardRect = card.getBoundingClientRect();
popup.style.left = '100%';
popup.style.top = '0';
// Reposition if popup would go off screen
requestAnimationFrame(() => {
const popupRect = popup.getBoundingClientRect();
if (popupRect.right > window.innerWidth) {
popup.style.left = 'auto';
popup.style.right = '100%';
}
});
}
getPriceRange(variants, productId) {
if (!variants || variants.length === 0) {
log('No variants provided to getPriceRange', { productId });
return { min: 0, max: 0 };
}
// Calculate total price (item + shipping) for each variant
const totalPrices = variants.map(v => {
const itemPrice = v.price?.discountedValue || 0;
const shippingCost = v.shipping?.cost || 0;
return itemPrice + shippingCost;
});
if (totalPrices.length === 0) {
log('Calculated totalPrices array is empty', { productId, variants });
return { min: 0, max: 0 };
}
return {
min: Math.min(...totalPrices),
max: Math.max(...totalPrices)
};
}
getFreeShippingThreshold(variants, productId) {
return variants.reduce((threshold, variant) => {
return variant.shipping.freeThreshold !== null
? Math.min(threshold || Infinity, variant.shipping.freeThreshold)
: threshold;
}, null);
}
addPriceDistributionGraph(container, bestVariant, priceRange, productId) {
const graph = document.createElement('div');
graph.className = 'ali-real-price-distribution';
const marker = document.createElement('div');
marker.className = 'ali-real-price-distribution-marker';
const position = ((bestVariant.price.discountedValue - priceRange.min) /
(priceRange.max - priceRange.min)) * 100;
marker.style.left = `${position}%`;
graph.appendChild(marker);
container.appendChild(graph);
}
// Helper method to get element depth in DOM
getElementDepth(element) {
let depth = 0;
let current = element;
while (current.parentNode) {
depth++;
current = current.parentNode;
}
return depth;
}
}
// Initialize the userscript
async function init() {
log('Initializing script...');
// --- Load Cache Disable Preference FIRST ---
const storedValue = await GM.getValue('aliexpress_disable_cache', false);
log(`[init] Loaded 'aliexpress_disable_cache' from GM.getValue: ${storedValue} (Type: ${typeof storedValue})`);
isCacheDisabled = storedValue;
log(`[init] Set global isCacheDisabled to: ${isCacheDisabled}`);
// --- Instantiate LoadingManager AFTER loading preference --- // MOVED LATER
// const loadingManager = new LoadingManager(); // Instance is global now
// Add styles
try {
GM_addStyle(STYLES);
log('Styles added successfully');
} catch (error) {
log('Error adding styles:', error);
}
// Create instances of main classes (except DOMEnhancer)
const dataManager = new DataManager();
globalCache = dataManager.cache; // Store cache instance globally
const priceContextCalculator = new PriceContextCalculator();
// const domEnhancer = new DOMEnhancer(dataManager, priceContextCalculator); // MOVED LATER
// Initialize token
await dataManager.initializeToken();
log('Token initialized (or checked)');
// Start observing product cards - COUNT FIRST
const productCards = document.querySelectorAll(SELECTORS.productCard);
log('Found initial product cards:', productCards.length);
// Initialize loading manager with total number of products
// Uses the GLOBAL loadingManager instance implicitly now
if (productCards.length > 0) {
loadingManager.completedItems = 0;
loadingManager.startLoading(productCards.length);
log(`Loading manager initialized: total=${loadingManager.totalItems}, completed=${loadingManager.completedItems}`);
} else {
// Ensure totalItems is 0 if no cards found initially
loadingManager.totalItems = 0;
loadingManager.completedItems = 0;
loadingManager.updateProgress(); // Show 0/0
log(`Loading manager initialized: total=0 (no initial cards)`);
}
// --- Create DOMEnhancer AFTER initializing loadingManager ---
const domEnhancer = new DOMEnhancer(dataManager, priceContextCalculator);
log('DOMEnhancer created');
// --- Observe Initial Cards ---
productCards.forEach(card => {
const productId = utils.extractProductId(card);
if (productId) {
log('Observing and immediately enhancing initial card:', productId, { productId });
domEnhancer.observer.observe(card); // Still observe in case manual call fails or for other reasons
domEnhancer.enhanceProductCard(card, productId); // Start processing immediately, do not await
} else {
log('Skipping initial card - no product ID found', card);
// If no ID, we can't process, and don't need to increment total/complete counts for it.
// Adjust loading manager counts if necessary (though startLoading already set the total based on querySelectorAll count)
// Maybe decrement totalItems if an initial card lacks an ID? Or handle it gracefully in itemComplete?
// For now, just log and skip.
}
});
// --- Handle dynamic content loading (MutationObserver) ---
const observer = new MutationObserver((mutations) => {
log('DOM mutation detected');
let newCards = [];
mutations.forEach((mutation) => {
mutation.addedNodes.forEach((node) => {
if (node.nodeType === Node.ELEMENT_NODE) {
// Check if the added node itself is a product card
if (node.matches(SELECTORS.productCard)) {
newCards.push(node);
} else {
// Check if the added node contains product cards
const cards = node.querySelectorAll(SELECTORS.productCard);
if (cards.length > 0) {
newCards.push(...Array.from(cards));
}
}
}
});
});
// Filter out cards that might have already been processed
// (e.g., if mutation observer fires multiple times rapidly)
newCards = newCards.filter(card => !domEnhancer.processedCards.has(card));
if (newCards.length > 0) {
log('Found new product cards via MutationObserver:', newCards.length);
// Update loading manager with new total
const newTotal = loadingManager.totalItems + newCards.length;
// Reset completed count only if starting from zero
if (loadingManager.totalItems === 0) {
log('First batch of dynamic items detected, resetting completed count.');
loadingManager.completedItems = 0;
}
loadingManager.startLoading(newTotal); // Sets new total, updates display
newCards.forEach(card => {
const productId = utils.extractProductId(card);
if (productId) { // Ensure we have an ID before observing
log('Observing new card found by MutationObserver:', productId, { productId });
domEnhancer.observer.observe(card);
} else {
log('Skipping observation for new card - no product ID found', card);
}
});
}
});
observer.observe(document.body, {
childList: true,
subtree: true
});
log('Mutation observer started');
}
// Start the script
if (document.readyState === 'loading') {
log('Document still loading, waiting for DOMContentLoaded');
document.addEventListener('DOMContentLoaded', init);
} else {
log('Document already loaded, initializing immediately');
init();
}
// --- Function to handle cache disable checkbox change ---
async function handleDisableCacheChange(event) {
isCacheDisabled = event.target.checked;
log('Cache disabled preference changed:', isCacheDisabled);
await GM.setValue('aliexpress_disable_cache', isCacheDisabled);
// Optional: Clear cache when disabling?
if (isCacheDisabled && globalCache) {
await globalCache.clear();
log('Cache cleared because it was disabled.');
// Optionally alert the user or reload
// alert('Cache disabled and cleared.');
}
}
})();