@rocketsearch/nuxt-uappi 0.1.0

package/runtime/rocket.js

@@ -0,0 +1,632 @@
+/**
+ * Núcleo do Rocket Search para Uappi — port do rs-config.js do SDK Linx 2.0.0.
+ *
+ * Sem Vue e sem Nuxt de propósito: só fetch + sessionStorage, para poder ser
+ * compartilhado com outras plataformas. O plugin injeta o contexto da página
+ * (setPage) e o cookie de sessão; o resto é o comportamento da Linx.
+ *
+ * Diferenças para a Linx:
+ * - contexto da página vem do Vuex do tema (setDadosPageAtual), não do browsingContext;
+ * - sessionId = sempre o id anônimo local (ver getSessionId);
+ * - add_to_cart vem do interceptor do $axios (plugin), com o payload da Uappi;
+ * - purchase fica para o GTM do checkout (o checkout da Uappi não roda no Nuxt).
+ */
+
+const SHOWCASE_ATTR_KEY = 'rs_showcase_attr';
+const SHOWCASE_ATTR_TTL = 30 * 60 * 1000;
+// Mapa persistente produto -> vitrine (last-touch por produto). Diferente do slot único,
+// NÃO é apagado no add_to_cart: sobrevive até o checkout para atribuir GMV no purchase.
+const SHOWCASE_ATTR_MAP_KEY = 'rs_showcase_attr_map';
+const SEARCH_ATTR_KEY = 'rs_search_attr';
+const PENDING_CART_EVENTS_KEY = 'rs_pending_add_to_cart_events';
+const ANON_SESSION_KEY = 'rs_anon_session_id';
+const ANON_SESSION_TTL = 30 * 60 * 1000;
+const LAST_SECTION_KEY = 'rs_last_section';
+const DEBUG_TOKEN_KEY = 'rs_debug_token';
+const SHOWCASE_DEBUG_KEY = 'rs_showcase_debug';
+// 2h — em sincronia com DEBUG_SESSION_TTL_SECONDS no backend.
+const DEBUG_TTL = 7200000;
+
+const isBrowser = typeof window !== 'undefined';
+
+function storageGet (key) {
+  try {
+    const raw = sessionStorage.getItem(key);
+    return raw ? JSON.parse(raw) : null;
+  }
+  catch (e) {
+    return null;
+  }
+}
+
+function storageSet (key, value) {
+  try {
+    sessionStorage.setItem(key, JSON.stringify(value));
+  }
+  catch (e) { /* storage bloqueado (aba anônima/iframe) */ }
+}
+
+function storageRemove (key) {
+  try {
+    sessionStorage.removeItem(key);
+  }
+  catch (e) { /* storage bloqueado */ }
+}
+
+// Converte valor cru em número > 0, ou null. Evita NaN: `Number('null')` é NaN, e
+// NaN != null é true — curto-circuitava o cascade de preço e o totalValue saía null.
+export function toPositiveNumber (value) {
+  if (value == null || value === '') return null;
+  const n = Number(value);
+  return isFinite(n) && n > 0 ? n : null;
+}
+
+/**
+ * Clique que o browser abre em nova aba/janela por conta própria (ctrl/cmd/shift/alt,
+ * botão do meio ou target="_blank"). Nesses casos NÃO se chama preventDefault().
+ */
+export function isModifiedClick (event, el) {
+  if (!event) return false;
+  if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return true;
+  if (event.button === 1 || event.which === 2) return true;
+  const target = el && el.getAttribute ? el.getAttribute('target') : null;
+  return !!target && target !== '_self';
+}
+
+// Vocabulário de SEÇÃO (aba Navegação/Jornada): home|pdp|category|list|brand|search|other.
+// Mapeia o `estrutura.nivel` que a Front API da Uappi devolve em toda página.
+export function sectionFromNivel (nivel) {
+  switch (nivel) {
+    case 'home': return 'home';
+    case 'product/detail': return 'pdp';
+    case 'product/listing/category': return 'category';
+    case 'product/listing/landing-page': return 'list';
+    case 'product/listing/brand': return 'brand';
+    case 'product/listing/search': return 'search';
+    default: return null;
+  }
+}
+
+// Vocabulário da API de vitrines/banners (pageType): product|category|home|search|cart|checkout.
+export function pageTypeFromSection (section) {
+  if (section === 'pdp') return 'product';
+  if (section === 'list' || section === 'brand') return 'category';
+  if (section === 'other') return '';
+  return section || '';
+}
+
+function randomSessionId () {
+  let random = '';
+  try {
+    const bytes = new Uint8Array(8);
+    crypto.getRandomValues(bytes);
+    random = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+  }
+  catch (e) {
+    random = Math.random().toString(16).slice(2) + Math.random().toString(16).slice(2);
+  }
+  return 'rs-anon-' + Date.now().toString(36) + '-' + random.slice(0, 16);
+}
+
+export function createRocket (config) {
+  const rocket = {
+    config,
+    storeId: config.storeId,
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl
+  };
+
+  // ---- Contexto da página (equivalente ao browsingContext da Linx) ----
+
+  let page = { section: null, productId: null, categoryId: null, product: null };
+
+  rocket.setPage = function (next) {
+    page = Object.assign({ section: null, productId: null, categoryId: null, product: null }, next);
+    pageShowcases = null;
+  };
+  rocket.getPage = () => page;
+
+  function resolveSection () {
+    if (page.section) return page.section;
+    if (!isBrowser) return 'other';
+    const path = (location.pathname || '').toLowerCase();
+    if (path === '/' || path === '') return 'home';
+    if (path.indexOf(config.searchPagePath) === 0) return 'search';
+    if (path.indexOf('/checkout') === 0) return 'checkout';
+    return 'other';
+  }
+  rocket.resolveSection = resolveSection;
+
+  function resolvePageType (type) {
+    if (type) return String(type).toLowerCase();
+    return pageTypeFromSection(resolveSection());
+  }
+  rocket.resolvePageType = resolvePageType;
+
+  // ---- Sessão ----
+
+  // Sessão = id local, igual à Linx para shopper anônimo. NÃO usamos o PHPSESSID da Uappi:
+  // ele é o token de sessão do cliente, e a Uappi o reemite como HttpOnly pelas respostas
+  // da /api — o JS o lê na 1ª carga e perde depois, trocando o sessionId no meio da visita
+  // (visto na homolog: page_view com um id, click/view seguintes com outro). O checkout
+  // roda na mesma origem/aba, então o GTM de purchase lê este id do sessionStorage.
+  let anonSessionFallback = null;
+
+  function clearAnonSessionId () {
+    anonSessionFallback = null;
+    storageRemove(ANON_SESSION_KEY);
+  }
+  rocket.clearAnonSessionId = clearAnonSessionId;
+
+  function getOrCreateAnonSessionId () {
+    let record = storageGet(ANON_SESSION_KEY);
+    if (!record || !record.id || !record.ts) record = anonSessionFallback;
+    if (record && Date.now() - record.ts > ANON_SESSION_TTL) {
+      clearAnonSessionId();
+      record = null;
+    }
+    // ts renovado a cada leitura: expira por inatividade, não por tempo absoluto.
+    const next = { id: record ? record.id : randomSessionId(), ts: Date.now() };
+    anonSessionFallback = next;
+    storageSet(ANON_SESSION_KEY, next);
+    return next.id;
+  }
+
+  rocket.getSessionId = function () {
+    return Promise.resolve(isBrowser ? getOrCreateAnonSessionId() : null);
+  };
+
+  // Aguarda o sessionId com teto de tempo: o split A/B das vitrines precisa dele para ser
+  // determinístico, mas a vitrine não pode ficar refém disso.
+  function getSessionIdWithTimeout () {
+    return Promise.race([
+      rocket.getSessionId().catch(() => null),
+      new Promise(resolve => setTimeout(() => resolve(null), 2000))
+    ]);
+  }
+
+  // ---- HTTP ----
+
+  function headers (extra) {
+    const h = Object.assign({ 'X-API-Key': config.apiKey }, extra);
+    // No servidor não há navegador para mandar Origin — a API pública exige um autorizado.
+    if (!isBrowser && config.siteOrigin) h.Origin = config.siteOrigin;
+    return h;
+  }
+
+  function query (params) {
+    const search = new URLSearchParams();
+    Object.keys(params).forEach((key) => {
+      const value = params[key];
+      if (value !== undefined && value !== null) search.set(key, value);
+    });
+    return search.toString();
+  }
+
+  // ---- Caches de preço (cascade do totalValue no add_to_cart) ----
+
+  const showcasePriceCache = {};
+  const searchPriceCache = {};
+  rocket._searchPriceCache = searchPriceCache;
+
+  rocket.rememberSearchPrices = function (products) {
+    (products || []).forEach((p) => {
+      if (p && p.id != null && p.price != null) searchPriceCache[String(p.id)] = Number(p.price);
+    });
+  };
+
+  function getShowcaseProductPrice (showcaseId, productId) {
+    if (!showcaseId || !productId) return null;
+    const byShowcase = showcasePriceCache[String(showcaseId)];
+    const price = byShowcase ? byShowcase[String(productId)] : null;
+    return price != null ? price : null;
+  }
+
+  function findPriceInAnyShowcase (productId) {
+    if (!productId) return null;
+    const pid = String(productId);
+    const keys = Object.keys(showcasePriceCache);
+    for (let i = 0; i < keys.length; i++) {
+      const price = showcasePriceCache[keys[i]][pid];
+      if (price != null) return price;
+    }
+    return null;
+  }
+
+  // ---- API ----
+
+  rocket.autocomplete = async function (term) {
+    const res = await fetch(config.apiUrl + '/autocomplete?' + query({ storeId: config.storeId, q: term || '' }), {
+      headers: headers()
+    });
+    return res.json();
+  };
+
+  rocket.search = async function (params) {
+    const sessionId = await rocket.getSessionId();
+    const qs = Object.assign({ storeId: config.storeId }, params, {
+      // Só ordem + preço: os dados do card vêm da própria Uappi (mesmo desenho da Linx,
+      // que pedia id,price e renderizava pelo widget nativo da loja).
+      fields: 'id,price',
+      sessionId: sessionId || ''
+    });
+    const res = await fetch(config.apiUrl + '/search?' + query(qs), { headers: headers() });
+    const data = await res.json();
+    if (isBrowser && data && data.redirect && data.redirect.type === 'url' && data.redirect.url) {
+      window.location.href = data.redirect.url;
+    }
+    return data;
+  };
+
+  rocket.searchImage = async function (file, params) {
+    if (typeof file !== 'string') throw new Error('File must be a base64 string or URL');
+    const sessionId = await rocket.getSessionId();
+    const body = Object.assign({ sessionId }, params);
+    if (/^data:image\/[a-zA-Z]+;base64,/.test(file)) {
+      body.imageBase64 = file;
+    }
+    else {
+      try {
+        body.imageUrl = new URL(file).toString();
+      }
+      catch (e) {
+        throw new Error('Invalid image format. Expected base64 or URL');
+      }
+    }
+    const res = await fetch(config.apiUrl + '/search/image?' + query({ storeId: config.storeId }), {
+      method: 'POST',
+      headers: headers({ 'Content-Type': 'application/json' }),
+      body: JSON.stringify(body)
+    });
+    return res.json();
+  };
+
+  rocket.getShowcasesByContext = async function (type) {
+    const pageType = resolvePageType(type);
+    if (!pageType) return [];
+    const sessionId = await getSessionIdWithTimeout();
+    const params = { storeId: config.storeId, pageType, page: pageType, sessionId };
+    if (pageType === 'product' && page.productId) params.productId = page.productId;
+    if (pageType === 'category' && page.categoryId) params.categoryId = page.categoryId;
+
+    const res = await fetch(config.apiUrl + '/showcases/context?' + query(params), { headers: headers() });
+    const showcases = await res.json();
+    if (Array.isArray(showcases)) {
+      showcases.forEach((showcase) => {
+        if (!showcase || !showcase.id || !Array.isArray(showcase.products)) return;
+        const cache = showcasePriceCache[String(showcase.id)] = {};
+        showcase.products.forEach((p) => {
+          if (p && p.id != null && p.price != null) cache[String(p.id)] = Number(p.price);
+        });
+      });
+    }
+    return Array.isArray(showcases) ? showcases : [];
+  };
+
+  // Uma chamada por página, repartida entre os slots (<RocketShowcase position>) — na Linx
+  // era o fetchShowCases único distribuindo por data-rocket-showcase-position. Zera no setPage.
+  let pageShowcases = null;
+  rocket.getPageShowcases = function (type) {
+    if (!pageShowcases) pageShowcases = rocket.getShowcasesByContext(type).catch(() => []);
+    return pageShowcases;
+  };
+
+  // Só banners (DTO banner-native). Gated pela flag `banners`: loja sem ela recebe [].
+  rocket.getBannersByContext = async function (type, options) {
+    const pageType = resolvePageType(type);
+    if (!pageType) return [];
+    const opts = options || {};
+    try {
+      const sessionId = await getSessionIdWithTimeout();
+      const params = { storeId: config.storeId, pageType, sessionId, position: opts.position };
+      const res = await fetch(config.apiUrl + '/banners/context?' + query(params), { headers: headers() });
+      if (!res.ok) return [];
+      const banners = await res.json();
+      return Array.isArray(banners) ? banners : [];
+    }
+    catch (e) {
+      // Banner é conteúdo promocional — falha não pode quebrar a página.
+      return [];
+    }
+  };
+
+  // ---- Atribuição (sessionStorage) ----
+
+  function saveShowcaseAttribution (showcaseId, productId, price, experiment) {
+    if (!showcaseId) return;
+    const record = {
+      showcaseId,
+      productId: productId || null,
+      productIds: productId ? [String(productId)] : null,
+      price: price != null ? Number(price) : null,
+      ts: Date.now()
+    };
+    if (experiment && experiment.experimentId != null) {
+      record.experimentId = experiment.experimentId;
+      record.variantId = experiment.variantId != null ? experiment.variantId : null;
+    }
+    storageSet(SHOWCASE_ATTR_KEY, record);
+  }
+
+  function getShowcaseAttribution (productId) {
+    const attr = storageGet(SHOWCASE_ATTR_KEY);
+    if (!attr || !attr.ts || Date.now() - attr.ts > SHOWCASE_ATTR_TTL) {
+      storageRemove(SHOWCASE_ATTR_KEY);
+      return null;
+    }
+    if (productId && Array.isArray(attr.productIds) && attr.productIds.length &&
+      attr.productIds.indexOf(String(productId)) === -1) return null;
+    return attr;
+  }
+
+  function saveShowcaseAttributionEntry (showcaseId, productId, position) {
+    if (!showcaseId || productId == null || productId === '') return;
+    const map = storageGet(SHOWCASE_ATTR_MAP_KEY) || {};
+    const now = Date.now();
+    Object.keys(map).forEach((key) => {
+      if (!map[key] || !map[key].ts || now - map[key].ts > SHOWCASE_ATTR_TTL) delete map[key];
+    });
+    map[String(productId)] = { showcaseId, position: position != null && position >= 0 ? position : null, ts: now };
+    storageSet(SHOWCASE_ATTR_MAP_KEY, map);
+  }
+
+  function getSearchAttribution () {
+    const attr = storageGet(SEARCH_ATTR_KEY);
+    if (!attr || !attr.ts || Date.now() - attr.ts > SHOWCASE_ATTR_TTL) {
+      storageRemove(SEARCH_ATTR_KEY);
+      return null;
+    }
+    return attr;
+  }
+
+  rocket.getShowcaseAttribution = getShowcaseAttribution;
+  rocket.getSearchAttribution = getSearchAttribution;
+
+  // ---- Eventos ----
+
+  function readDebugToken () {
+    const parsed = storageGet(DEBUG_TOKEN_KEY);
+    if (!parsed) return null;
+    if (parsed.exp > Date.now()) return parsed.token;
+    storageRemove(DEBUG_TOKEN_KEY);
+    return null;
+  }
+
+  rocket.dispatchEvent = async function (eventType, data) {
+    if (!isBrowser) return null;
+    // Carimba a seção em TODO evento, num único ponto — o backend agrega por pageType.
+    data = data || {};
+    data.meta = data.meta || {};
+    if (!data.meta.pageType) data.meta.pageType = resolveSection();
+
+    if (eventType === 'click' && data.vitrine && data.productId) {
+      saveShowcaseAttribution(data.vitrine, data.productId, getShowcaseProductPrice(data.vitrine, data.productId), {
+        experimentId: data.experimentId,
+        variantId: data.variantId
+      });
+      saveShowcaseAttributionEntry(data.vitrine, data.productId, data.position);
+    }
+    if (eventType === 'click' && (data.meta.source === 'autocomplete' || data.meta.source === 'search-page')) {
+      storageSet(SEARCH_ATTR_KEY, { source: data.meta.source, ts: Date.now() });
+    }
+
+    const sessionId = await rocket.getSessionId();
+    const payload = Object.assign({
+      storeId: config.storeId,
+      eventType,
+      type: eventType,
+      sessionId: sessionId || null,
+      timestamp: new Date().toISOString()
+    }, data);
+
+    const reqHeaders = headers({ 'Content-Type': 'application/json' });
+    // Token de debug ativo: o backend roteia o evento só para o Redis (não grava no banco).
+    const debugToken = readDebugToken();
+    if (debugToken) {
+      reqHeaders['X-RS-Debug'] = debugToken;
+      payload.pageUrl = window.location.href;
+    }
+    if (config.debug) console.log('[RocketSearch] event', payload);
+
+    const res = await fetch(config.apiUrl + '/events', {
+      method: 'POST',
+      headers: reqHeaders,
+      body: JSON.stringify(payload),
+      keepalive: true
+    });
+    if (debugToken) {
+      res.clone().json().then((body) => {
+        if (body && (body._debug === 'expired' || body.code === 'DEBUG_SESSION_EXPIRED')) storageRemove(DEBUG_TOKEN_KEY);
+      }).catch(() => {});
+    }
+    return res;
+  };
+
+  /**
+   * Envia o clique e navega na sequência. Clique normal: segura a navegação até o evento
+   * sair (o unload cancelaria o fetch), com teto de 600ms. Clique com modificador: o
+   * browser já abriu a aba — só dispara o evento. `navigate` recebe o href (o componente
+   * passa o $router.push, que não descarrega a página).
+   *
+   * @returns {boolean} true se assumiu a navegação.
+   */
+  rocket.trackThenNavigate = function (event, el, href, send, navigate) {
+    if (!href || isModifiedClick(event, el)) {
+      try {
+        send();
+      }
+      catch (e) { /* best-effort */ }
+      return false;
+    }
+    if (event && typeof event.preventDefault === 'function') event.preventDefault();
+    let navigated = false;
+    const go = () => {
+      if (navigated) return;
+      navigated = true;
+      if (navigate) navigate(href);
+      else window.location.href = href;
+    };
+    setTimeout(go, 600);
+    Promise.resolve().then(send).then(go, go);
+    return true;
+  };
+  rocket.isModifiedClick = isModifiedClick;
+
+  // Jornada: page_view SOMENTE quando a seção muda na sessão (dedupe no sessionStorage),
+  // para reconstruir o fluxo entre seções sem 1 evento por pageview.
+  rocket.firePageViewIfSectionChanged = function () {
+    const section = resolveSection();
+    let prev = null;
+    try {
+      prev = sessionStorage.getItem(LAST_SECTION_KEY);
+    }
+    catch (e) { /* storage bloqueado */ }
+    if (prev === section) return;
+    try {
+      sessionStorage.setItem(LAST_SECTION_KEY, section);
+    }
+    catch (e) { /* storage bloqueado */ }
+    rocket.dispatchEvent('page_view', { meta: { pageType: section, fromSection: prev || null } }).catch(() => {});
+  };
+
+  rocket.fireProductView = function () {
+    if (!page.productId) return;
+    const viewData = { productId: page.productId };
+    const showcaseAttr = getShowcaseAttribution(page.productId);
+    const searchAttr = getSearchAttribution();
+    if (showcaseAttr && showcaseAttr.showcaseId) viewData.meta = { source: 'showcase:' + showcaseAttr.showcaseId };
+    else if (searchAttr && searchAttr.source) viewData.meta = { source: searchAttr.source };
+    rocket.dispatchEvent('view', viewData).catch(() => {});
+  };
+
+  // ---- add_to_cart (payload do POST /v2/front/checkout/cart da Uappi) ----
+
+  function getPendingCartEvents () {
+    const events = storageGet(PENDING_CART_EVENTS_KEY);
+    if (!Array.isArray(events)) return [];
+    return events.filter(e => e && e.ts && Date.now() - e.ts <= SHOWCASE_ATTR_TTL);
+  }
+
+  function setPendingCartEvents (events) {
+    storageSet(PENDING_CART_EVENTS_KEY, events.slice(-20));
+  }
+
+  function removePendingCartEvent (id) {
+    setPendingCartEvents(getPendingCartEvents().filter(e => e.id !== id));
+  }
+
+  // O evento entra na fila ANTES do envio: se a página navegar e cancelar o fetch, o
+  // próximo carregamento reenvia (flushPendingCartEvents).
+  function sendCartEvent (eventData) {
+    const event = { id: Date.now() + '-' + Math.random().toString(36).slice(2), eventType: 'add_to_cart', data: eventData, ts: Date.now() };
+    setPendingCartEvents(getPendingCartEvents().concat(event));
+    rocket.dispatchEvent('add_to_cart', eventData).then(() => removePendingCartEvent(event.id)).catch(() => {});
+  }
+
+  rocket.flushPendingCartEvents = function () {
+    getPendingCartEvents().forEach((event) => {
+      rocket.dispatchEvent(event.eventType, event.data).then(() => removePendingCartEvent(event.id)).catch(() => {});
+    });
+  };
+
+  function resolveProductPrice (productId, attr) {
+    if (page.productId && String(page.productId) === String(productId) && page.product) {
+      const pagePrice = toPositiveNumber(page.product.precos && page.product.precos.por);
+      if (pagePrice != null) return pagePrice;
+    }
+    if (attr && attr.price != null) return attr.price;
+    if (attr && attr.showcaseId) {
+      const price = getShowcaseProductPrice(attr.showcaseId, productId);
+      if (price != null) return price;
+    }
+    const showcasePrice = findPriceInAnyShowcase(productId);
+    if (showcasePrice != null) return showcasePrice;
+    const cached = searchPriceCache[String(productId)];
+    return cached != null ? cached : null;
+  }
+
+  function resolveProductSource (productId, attr, searchAttr) {
+    if (attr && attr.showcaseId) return 'showcase:' + attr.showcaseId;
+    if (searchAttr && searchAttr.source) return searchAttr.source;
+    if (searchPriceCache[String(productId)] != null) return 'search-page';
+    return null;
+  }
+
+  rocket.trackAddToCart = function (payload) {
+    const itens = payload && Array.isArray(payload.itens) ? payload.itens : [];
+    const products = itens
+      .filter(item => item && item.idProduto != null)
+      .map(item => ({
+        productId: Number(item.idProduto),
+        skuId: item.idAtributoSimples != null ? Number(item.idAtributoSimples) : null,
+        quantity: Number(item.quantidade) || 1
+      }));
+    if (!products.length) return;
+
+    const attr = getShowcaseAttribution(products[0].productId);
+    const searchAttr = getSearchAttribution();
+    const experiment = attr && attr.experimentId != null
+      ? { experimentId: attr.experimentId, variantId: attr.variantId != null ? attr.variantId : null }
+      : {};
+
+    if (products.length === 1) {
+      const p = products[0];
+      const meta = { quantity: p.quantity };
+      const price = resolveProductPrice(p.productId, attr);
+      const source = resolveProductSource(p.productId, attr, searchAttr);
+      if (source) meta.source = source;
+      if (price != null) meta.totalValue = price * p.quantity;
+      const eventData = Object.assign({ productId: p.productId, meta }, experiment);
+      if (attr && attr.showcaseId) eventData.vitrine = Number(attr.showcaseId);
+      sendCartEvent(eventData);
+    }
+    else {
+      const items = products.map((p) => {
+        const item = { productId: p.productId, quantity: p.quantity };
+        if (p.skuId) item.skuId = p.skuId;
+        const price = resolveProductPrice(p.productId, attr);
+        if (price != null) item.totalValue = price * p.quantity;
+        const source = resolveProductSource(p.productId, attr, searchAttr);
+        if (source) item.source = source;
+        if (attr && attr.showcaseId && String(attr.productId) === String(p.productId)) item.showcaseId = Number(attr.showcaseId);
+        return item;
+      });
+      sendCartEvent(Object.assign({ items }, experiment));
+    }
+    if (attr) storageRemove(SHOWCASE_ATTR_KEY);
+  };
+
+  // ---- Debug (?rocket-search-debug=true e ?rs_debug=TOKEN persistem 2h na sessão) ----
+
+  rocket.initDebugFromUrl = function () {
+    if (!isBrowser) return;
+    let params;
+    try {
+      params = new URLSearchParams(location.search);
+    }
+    catch (e) {
+      return;
+    }
+
+    const showcaseDebug = params.get('rocket-search-debug');
+    if (showcaseDebug === 'false' || showcaseDebug === '0') {
+      storageRemove(SHOWCASE_DEBUG_KEY);
+    }
+    else if (showcaseDebug === 'true' || showcaseDebug === '1') {
+      storageSet(SHOWCASE_DEBUG_KEY, { exp: Date.now() + DEBUG_TTL });
+    }
+    const active = storageGet(SHOWCASE_DEBUG_KEY);
+    if (active && active.exp > Date.now()) document.body.classList.add('rocket-search-debug');
+    else storageRemove(SHOWCASE_DEBUG_KEY);
+
+    const token = params.get('rs_debug');
+    if (token) {
+      const existing = storageGet(DEBUG_TOKEN_KEY);
+      if (!existing || existing.token !== token || existing.exp <= Date.now()) {
+        storageSet(DEBUG_TOKEN_KEY, { token, exp: Date.now() + DEBUG_TTL });
+      }
+    }
+  };
+
+  return rocket;
+}

package/runtime/uappi.js

@@ -0,0 +1,71 @@
+/**
+ * Dados de produto vindos da própria Uappi.
+ *
+ * A Rocket decide ordem/filtro/paginação; o card mostra o produto como a loja o tem
+ * (preço, parcelamento, selos, rota). É o mesmo desenho da Linx, que pedia só id,price
+ * à Rocket e renderizava pelo widget nativo product_list_by_id.
+ *
+ * Aqui o equivalente é a vitrine "últimos vistos" da Front API: recebe uma lista de ids
+ * e devolve os produtos completos, na ordem pedida (conferido na homolog Daikin com 24
+ * ids). Produto inativo/indisponível é omitido — por isso a reordenação abaixo.
+ */
+
+export async function fetchUappiProducts ($axios, ids) {
+  const list = (ids || []).map(String).filter(Boolean);
+  if (!list.length || !$axios) return [];
+
+  const data = await $axios.$get('/v2/front/showcase/products/ultimos-vistos', {
+    params: { productId: 0, seenProducts: list.join(';'), limit: list.length }
+  });
+  const byId = {};
+  ((data && data.produtos) || []).forEach((p) => {
+    if (p && p.id != null) byId[String(p.id)] = p;
+  });
+  return list.map(id => byId[id]).filter(Boolean);
+}
+
+// Tamanhos de imagem da Uappi, do menor para o maior. Se o pedido não existir no
+// produto, usa o vizinho mais próximo (mesma regra do mediaSize da Linx).
+const IMAGE_SIZES = ['thumb', 'small', 'medium', 'big', 'zoom'];
+
+export function productImage (product, size) {
+  const imagens = product && product.midias && product.midias.imagens;
+  const arquivos = Array.isArray(imagens) && imagens[0] && imagens[0].arquivos;
+  if (!arquivos) return '';
+
+  let start = IMAGE_SIZES.indexOf(String(size || '').toLowerCase());
+  if (start < 0) start = IMAGE_SIZES.indexOf('medium');
+  for (let step = 0; step < IMAGE_SIZES.length; step++) {
+    const up = IMAGE_SIZES[start + step];
+    if (up && arquivos[up]) return arquivos[up];
+    const down = IMAGE_SIZES[start - step];
+    if (down && arquivos[down]) return arquivos[down];
+  }
+  return '';
+}
+
+export function productPath (product) {
+  if (product && product.rota && product.rota.route) return product.rota.route;
+  if (product && product.url) {
+    try {
+      return new URL(product.url).pathname;
+    }
+    catch (e) {
+      return product.url;
+    }
+  }
+  return '';
+}
+
+export function productPrice (product) {
+  const precos = product && product.precos;
+  if (!precos) return null;
+  const value = precos.por != null ? precos.por : precos.vista;
+  const n = Number(value);
+  return isFinite(n) && n > 0 ? n : null;
+}
+
+export function formatCurrency (value) {
+  if (typeof value !== 'number' || isNaN(value)) return '';
+  return value.toLocaleString('pt-BR', { style: 'currency', currency: 'BRL' });
+}