mk-sdk-git 0.1.0

package/src/core/sanitize.js

@@ -0,0 +1,73 @@
+// sanitize.js — remove PII e campos pesados antes de enviar pro collector.
+
+// Campos que NUNCA devem sair da página (LGPD). Match case-insensitive parcial.
+const PII_PATTERNS = [
+  /email/i, /e-?mail/i, /cpf/i, /cnpj/i, /phone/i, /telefone/i, /celular/i,
+  /address/i, /endereco/i, /cep/i, /zip/i, /card/i, /cartao/i, /cvv/i,
+  /password/i, /senha/i, /token/i, /\bnome\b/i, /fullname/i, /firstname/i,
+  /lastname/i, /sobrenome/i, /birth/i, /nascimento/i, /rg\b/i
+];
+
+// Campos de imagem/binário pesados (não têm valor analítico).
+const HEAVY_KEYS = { imageUrl: 1, image: 1, thumbnail: 1, photo: 1, imageBase64: 1, src: 1 };
+const MAX_STRING_LEN = 2000;
+
+function isPiiKey(key) {
+  for (let i = 0; i < PII_PATTERNS.length; i++) {
+    if (PII_PATTERNS[i].test(key)) return true;
+  }
+  return false;
+}
+
+/**
+ * Sanitiza um objeto de params:
+ *   - Remove chaves PII completamente
+ *   - Troca campos de imagem por <key>Present: boolean
+ *   - Trunca strings > 2KB
+ *   - Percorre 1 nível de profundidade (objetos aninhados rasos)
+ */
+export function sanitize(data) {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) {
+    if (typeof data === 'string' && data.length > MAX_STRING_LEN) {
+      return data.slice(0, 200) + '...[truncated ' + data.length + 'B]';
+    }
+    return data;
+  }
+  const out = {};
+  for (const k in data) {
+    if (!Object.prototype.hasOwnProperty.call(data, k)) continue;
+    if (isPiiKey(k)) continue;                       // descarta PII
+    const v = data[k];
+    if (HEAVY_KEYS[k]) {
+      out[k + 'Present'] = !!v;
+      continue;
+    }
+    if (typeof v === 'string' && v.length > MAX_STRING_LEN) {
+      out[k] = v.slice(0, 200) + '...[truncated ' + v.length + 'B]';
+      continue;
+    }
+    if (v && typeof v === 'object' && !Array.isArray(v)) {
+      // 1 nível de recursão pra objetos aninhados (ex: product, ecommerce)
+      out[k] = sanitizeShallow(v);
+      continue;
+    }
+    out[k] = v;
+  }
+  return out;
+}
+
+function sanitizeShallow(obj) {
+  const out = {};
+  for (const k in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, k)) continue;
+    if (isPiiKey(k)) continue;
+    const v = obj[k];
+    if (HEAVY_KEYS[k]) { out[k + 'Present'] = !!v; continue; }
+    if (typeof v === 'string' && v.length > MAX_STRING_LEN) {
+      out[k] = v.slice(0, 200) + '...[truncated]';
+      continue;
+    }
+    out[k] = v;  // não recursa mais fundo (evita payload gigante)
+  }
+  return out;
+}

package/src/core/transport.js

@@ -0,0 +1,124 @@
+// transport.js — fila de eventos com batch, flush por timer/tamanho, sendBeacon.
+
+import { getConfig, log } from './config.js';
+import { getVisitorId, getSessionId } from './identity.js';
+import { sanitize } from './sanitize.js';
+
+let queue = [];
+let flushTimer = null;
+let siteContext = null;
+
+/**
+ * Define o contexto do site (uma vez por pageview). Injetado em todo batch.
+ */
+export function setSiteContext(ctx) {
+  siteContext = ctx;
+}
+
+/**
+ * Enfileira um evento. name é o nome cru (vira "page_<name>").
+ * Aplica sanitize automaticamente.
+ */
+export function track(name, params, tsOverride) {
+  const cfg = getConfig();
+  if (!cfg.projectId) {
+    // Sem projectId não dá pra enviar — enfileira em pré-buffer pequeno.
+    (track._pre = track._pre || []).push({ name, params, ts: tsOverride || Date.now() });
+    if (track._pre.length > 50) track._pre.shift();
+    return;
+  }
+
+  // Drena pré-buffer se houver
+  if (track._pre && track._pre.length) {
+    const pending = track._pre;
+    track._pre = [];
+    for (const p of pending) _enqueue(p.name, p.params, p.ts);
+  }
+
+  _enqueue(name, params, tsOverride);
+}
+
+function _enqueue(name, params, tsOverride) {
+  const cfg = getConfig();
+  const cleanParams = sanitize(params || {});
+  const finalName = 'page_' + normalizeName(name);
+  queue.push({
+    name: finalName,
+    ts: tsOverride || Date.now(),
+    params: cleanParams
+  });
+  log('queued', name, cleanParams);
+
+  // Canal de observação (extensão de QA). Inócuo em produção (observe=false).
+  if (cfg.observe) {
+    try {
+      window.postMessage({
+        __mkpixel: true,
+        event: { name: finalName, params: cleanParams },
+        site: siteContext ? { pageType: siteContext.pageType, platform: siteContext.platform, url: siteContext.url } : null
+      }, '*');
+    } catch (_) {}
+  }
+
+  if (queue.length >= cfg.batchMaxSize) {
+    flush();
+    return;
+  }
+  if (!flushTimer) {
+    flushTimer = setTimeout(() => { flushTimer = null; flush(); }, cfg.batchIntervalMs);
+  }
+}
+
+/**
+ * Normaliza nome: tira 'on' prefix, camelCase -> snake_case, evita prefixo page_ duplo.
+ */
+function normalizeName(name) {
+  if (typeof name !== 'string' || !name) return 'unknown';
+  let n = name.replace(/^on/, '');
+  n = n.replace(/[A-Z]/g, (m, i) => (i > 0 ? '_' : '') + m.toLowerCase());
+  if (n.indexOf('page_') === 0) n = n.slice(5);  // evita page_page_view
+  return n;
+}
+
+export function flush(useBeacon) {
+  if (queue.length === 0) return;
+  const cfg = getConfig();
+  if (!cfg.projectId || !cfg.collectorUrl) return;
+
+  const events = queue.splice(0, 50);
+  const payload = JSON.stringify({
+    product: cfg.product || undefined,
+    visitorId: getVisitorId(),
+    sessionId: getSessionId(),
+    events,
+    site: siteContext || undefined
+  });
+
+  const url = cfg.collectorUrl + '/v1/track';
+
+  if (useBeacon && navigator.sendBeacon) {
+    try {
+      const blob = new Blob([payload], { type: 'application/json' });
+      navigator.sendBeacon(url + '?projectId=' + encodeURIComponent(cfg.projectId), blob);
+      return;
+    } catch (_) {}
+  }
+
+  fetch(url, {
+    method: 'POST',
+    keepalive: true,
+    headers: { 'Content-Type': 'application/json', 'X-MK-Project-Id': cfg.projectId },
+    body: payload
+  }).catch(() => {});
+}
+
+// Flush final no unload pra não perder eventos pendentes.
+export function initUnloadFlush() {
+  try {
+    window.addEventListener('pagehide', () => flush(true));
+    window.addEventListener('beforeunload', () => flush(true));
+    document.addEventListener('visibilitychange', () => {
+      if (document.hidden) flush(true);
+    });
+  } catch (_) {}
+}

package/src/ecommerce/extractors.js

@@ -0,0 +1,144 @@
+// extractors.js — extração de produto/pedido/lista por sinais nativos genéricos.
+// O SKU por plataforma vive em ../platforms/ (resolveSku é re-exportado daqui só
+// por compatibilidade com quem já importava deste módulo). JSON-LD em ./jsonld.js.
+
+import { readJsonLd } from './jsonld.js';
+import { resolveSku } from '../platforms/index.js';
+
+export { readJsonLd };   // re-export (compat)
+export { resolveSku };   // re-export (compat) — a lógica por plataforma está em ../platforms/
+
+/**
+ * Extrai produto da PDP. Combina o resolveSku (por plataforma) com nome/preço/marca
+ * de JSON-LD, microdata ou Open Graph.
+ */
+export function extractProduct() {
+  const skuRes = resolveSku();
+  const products = readJsonLd(['Product']);
+
+  if (products.length > 0) {
+    const p = products[0];
+    const offer = Array.isArray(p.offers) ? p.offers[0] : p.offers;
+    return {
+      sku: skuRes ? skuRes.value : (p.sku || p.mpn || p.gtin13 || p.productID || null),
+      skuSource: skuRes ? skuRes.source : null,
+      name: typeof p.name === 'string' ? p.name : null,
+      price: offer ? parseFloat(offer.price || offer.lowPrice) || null : null,
+      currency: offer ? offer.priceCurrency : null,
+      brand: p.brand ? (typeof p.brand === 'string' ? p.brand : p.brand.name) : null,
+      category: p.category || null
+    };
+  }
+
+  const og = (prop) => {
+    const m = document.querySelector('meta[property="og:' + prop + '"], meta[property="product:' + prop + '"]');
+    return m ? m.getAttribute('content') : null;
+  };
+  const micro = (prop) => {
+    const e = document.querySelector('[itemprop="' + prop + '"]');
+    return e ? (e.getAttribute('content') || (e.textContent || '').trim()) : null;
+  };
+
+  if (skuRes || og('type') === 'product' || og('price:amount') || micro('name')) {
+    const priceRaw = micro('price') || og('price:amount');
+    return {
+      sku: skuRes ? skuRes.value : null,
+      skuSource: skuRes ? skuRes.source : null,
+      name: micro('name') || og('title') || (document.title || null),
+      price: priceRaw ? parseFloat(String(priceRaw).replace(',', '.')) || null : null,
+      currency: micro('priceCurrency') || og('price:currency') || null,
+      brand: micro('brand') || null,
+      category: null
+    };
+  }
+  return null;
+}
+
+/**
+ * Extrai dados de pedido/compra (página de confirmação).
+ * Cascata: JSON-LD Order > dataLayer (bônus) > meta > DOM scraping.
+ */
+export function extractOrder() {
+  const orders = readJsonLd(['Order', 'Invoice']);
+  if (orders.length > 0) {
+    const o = orders[0];
+    const total = o.totalPaymentDue ? parseFloat(o.totalPaymentDue.price) : parseFloat(o.price || o.total);
+    return {
+      orderId: o.orderNumber || o.confirmationNumber || o.identifier || null,
+      revenue: Number.isFinite(total) ? total : null,
+      currency: (o.totalPaymentDue && o.totalPaymentDue.priceCurrency) || o.priceCurrency || null,
+      source: 'jsonld'
+    };
+  }
+  try {
+    if (Array.isArray(window.dataLayer)) {
+      for (let i = window.dataLayer.length - 1; i >= 0; i--) {
+        const item = window.dataLayer[i];
+        if (item && item.event === 'purchase' && item.ecommerce) {
+          const ec = item.ecommerce;
+          return {
+            orderId: ec.transaction_id || ec.transactionId || null,
+            revenue: parseFloat(ec.value || ec.revenue) || null,
+            currency: ec.currency || ec.currencyCode || null,
+            itemCount: (ec.items || ec.products || []).length || null,
+            source: 'datalayer'
+          };
+        }
+      }
+    }
+  } catch (_) {}
+  const metaTotal = document.querySelector('meta[property="order:total"], meta[name="order-total"]');
+  if (metaTotal && metaTotal.content) {
+    return { orderId: null, revenue: parseFloat(metaTotal.content) || null, source: 'meta' };
+  }
+  const dom = scrapeOrderFromDom();
+  if (dom) return dom;
+  return null;
+}
+
+function scrapeOrderFromDom() {
+  try {
+    const totalSelectors = ['.order-total', '#order-total', '.total-price', '.order__total', '[data-order-total]', '.summary-total', '.grand-total'];
+    for (const sel of totalSelectors) {
+      const el = document.querySelector(sel);
+      if (el) {
+        const val = parseMoney(el.textContent);
+        if (val) return { orderId: scrapeOrderId(), revenue: val, source: 'dom' };
+      }
+    }
+    return null;
+  } catch (_) { return null; }
+}
+
+function scrapeOrderId() {
+  try {
+    const text = document.body.innerText || '';
+    const m = text.match(/(?:pedido|order|n[º°o]\.?)\s*#?\s*([A-Z0-9-]{4,})/i);
+    return m ? m[1] : null;
+  } catch (_) { return null; }
+}
+
+function parseMoney(str) {
+  if (!str) return null;
+  const cleaned = String(str).replace(/[^\d.,]/g, '');
+  if (!cleaned) return null;
+  let normalized;
+  if (cleaned.indexOf(',') > cleaned.indexOf('.')) normalized = cleaned.replace(/\./g, '').replace(',', '.');
+  else normalized = cleaned.replace(/,/g, '');
+  const n = parseFloat(normalized);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+/** Lê item list de categoria/busca (JSON-LD ItemList). */
+export function extractItemList() {
+  const lists = readJsonLd(['ItemList', 'CollectionPage']);
+  if (lists.length === 0) return null;
+  const list = lists[0];
+  const elements = list.itemListElement || (list.mainEntity && list.mainEntity.itemListElement) || [];
+  const skus = [];
+  for (const el of elements.slice(0, 50)) {
+    const item = el.item || el;
+    if (item && (item.sku || item.productID || item.name)) skus.push(item.sku || item.productID || item.name);
+  }
+  return skus.length > 0 ? { count: skus.length, skus: skus.slice(0, 20) } : null;
+}

package/src/ecommerce/funnel.js

@@ -0,0 +1,131 @@
+// funnel.js — emite eventos do funil de e-commerce reagindo ao pageType
+// detectado, + heurística de add_to_cart por clique. Sinais nativos, sem GA.
+
+import { track } from '../core/transport.js';
+import { log } from '../core/config.js';
+import { extractProduct, extractOrder, extractItemList } from './extractors.js';
+
+let purchaseEmittedThisLoad = false;
+
+// ─── Heurística de add_to_cart por texto de botão (mesma do collector) ───
+const ADD_TO_CART_PATTERNS = [
+  /\b(adicionar|adic\.?|colocar|incluir|jogar)\b.{0,30}\b(carrinho|sacola|sacolinha|bag)\b/i,
+  /\bcomprar\b(?!\s+(em|por|sem))/i,    // só BUTTON (checado no listener)
+  /\bcomprar\s*$/i,
+  /^add\s+to\s+(cart|bag)\b/i,
+  /^buy\s+(now|it|this)\b/i,
+  /^(sacolinha|carrinho|sacola)$/i
+];
+const PURCHASE_BTN_PATTERNS = [
+  /^finalizar(\s+(compra|pedido|pagamento))?\b/i,
+  /^(fechar|confirmar)\s+(compra|pedido|pagamento)\b/i,
+  /^pagar(\s+(agora|pedido))?\b/i,
+  /^(complete|place)\s+(purchase|order)\b/i,
+  /^checkout$/i
+];
+
+function matchAny(patterns, text) {
+  for (let i = 0; i < patterns.length; i++) if (patterns[i].test(text)) return true;
+  return false;
+}
+
+/**
+ * Chamado pelo autoTrack a cada pageview (incl. SPA). Emite o evento de funil
+ * correspondente ao tipo de página.
+ */
+export function onPageView(pageType) {
+  switch (pageType) {
+    case 'pdp': {
+      const product = extractProduct();
+      track('view_item', product || { sku: null });
+      break;
+    }
+    case 'category':
+    case 'search': {
+      const list = extractItemList();
+      track('view_item_list', list || { count: 0 });
+      break;
+    }
+    case 'cart':
+      track('view_cart', {});
+      break;
+    case 'checkout':
+      track('begin_checkout', {});
+      break;
+    case 'purchase':
+      emitPurchase();
+      break;
+  }
+}
+
+/**
+ * Emite purchase com dedup. Conversão é contada mesmo sem revenue.
+ */
+function emitPurchase() {
+  const order = extractOrder();
+
+  // Dedup: por orderId (cross-reload) ou por load (sem orderId)
+  if (order && order.orderId) {
+    const key = '_mk_purch_' + order.orderId;
+    try {
+      if (sessionStorage.getItem(key)) { log('purchase já contado', order.orderId); return; }
+      sessionStorage.setItem(key, '1');
+    } catch (_) {}
+  } else {
+    if (purchaseEmittedThisLoad) return;
+  }
+  purchaseEmittedThisLoad = true;
+
+  track('purchase', order || { revenue: null, _note: 'no_order_data_extracted' });
+  log('purchase emitido', order);
+}
+
+/**
+ * Listener dedicado pra detectar add_to_cart / begin_checkout por clique.
+ * Complementa os eventos de pageType (que não pegam o momento do clique).
+ */
+export function initFunnelClickTracking() {
+  if (!document.body) return;
+  let lastFire = 0;
+  document.body.addEventListener('click', (e) => {
+    try {
+      const now = Date.now();
+      if (now - lastFire < 150) return;
+      let el = e.target;
+      for (let i = 0; i < 5 && el && el !== document.body; i++) {
+        if (el.tagName === 'BUTTON' || el.tagName === 'A' ||
+            (el.getAttribute && el.getAttribute('role') === 'button')) break;
+        el = el.parentElement;
+      }
+      if (!el) return;
+      const isButton = el.tagName !== 'A';
+      const text = (el.textContent || '').replace(/\s+/g, ' ').trim();
+      if (!text || text.length > 80) return;
+
+      // add_to_cart
+      let isAdd = false;
+      if (matchAny([ADD_TO_CART_PATTERNS[0]], text)) isAdd = true;                 // adicionar+carrinho (qualquer tag)
+      else if (isButton && matchAny([ADD_TO_CART_PATTERNS[1]], text)) isAdd = true; // comprar (só button)
+      else if (isButton && matchAny([ADD_TO_CART_PATTERNS[2]], text)) isAdd = true; // termina em comprar
+      else if (matchAny(ADD_TO_CART_PATTERNS.slice(3), text)) isAdd = true;         // en + palavra única
+
+      if (isAdd) {
+        lastFire = now;
+        const product = extractProduct();
+        track('add_to_cart', {
+          via: 'click',
+          buttonText: text,
+          sku: product ? product.sku : null,
+          price: product ? product.price : null
+        });
+        return;
+      }
+
+      // begin_checkout (intenção)
+      if (isButton && matchAny(PURCHASE_BTN_PATTERNS, text)) {
+        lastFire = now;
+        track('begin_checkout', { via: 'click', buttonText: text });
+      }
+    } catch (_) {}
+  }, { capture: true, passive: true });
+}

package/src/ecommerce/jsonld.js

@@ -0,0 +1,23 @@
+// jsonld.js — leitura de dados estruturados JSON-LD. Helper genérico, sem deps
+// (usado por extractors, pageContext e platforms/generic — evita dependência circular).
+
+export function readJsonLd(types) {
+  const results = [];
+  try {
+    const nodes = document.querySelectorAll('script[type="application/ld+json"]');
+    for (const node of nodes) {
+      let parsed;
+      try { parsed = JSON.parse(node.textContent); } catch (_) { continue; }
+      const items = [];
+      if (Array.isArray(parsed)) items.push(...parsed);
+      else if (parsed['@graph']) items.push(...parsed['@graph']);
+      else items.push(parsed);
+      for (const item of items) {
+        if (!item || !item['@type']) continue;
+        const t = Array.isArray(item['@type']) ? item['@type'] : [item['@type']];
+        if (!types || types.some((wanted) => t.includes(wanted))) results.push(item);
+      }
+    }
+  } catch (_) {}
+  return results;
+}

package/src/index.js

@@ -0,0 +1,67 @@
+// index.js — entrypoint do mk-sdk. Inicia core tracking em todas as páginas
+// e expõe a API de try-on em window.mk.
+
+import { resolveConfig, getConfig, log } from './core/config.js';
+import { startAutoTrack } from './core/autoTrack.js';
+import { initUnloadFlush } from './core/transport.js';
+import { onPageView, initFunnelClickTracking } from './ecommerce/funnel.js';
+import { maybeMountButton, initPickerBridge } from './tryon/automount.js';
+import * as tryon from './tryon/bridge.js';
+
+(function boot() {
+  'use strict';
+  try {
+    const cfg = resolveConfig();
+
+    // ─── Core tracking: roda em TODA página ───────────────────────────────
+    function init() {
+      try {
+        initUnloadFlush();
+        initPickerBridge();   // canal de preview pro picker de posição do addon
+        tryon.initListener();  // escuta o provador (add_to_cart → cart-adapter)
+        if (cfg.autoTrack !== false) {
+          // funnel + auto-mount do botão reagem ao pageType a cada pageview
+          startAutoTrack((pageType, ctx) => {
+            onPageView(pageType, ctx);
+            maybeMountButton(pageType);
+          });
+          initFunnelClickTracking();
+        }
+        log('mk-sdk iniciado', { projectId: cfg.projectId, collectorUrl: cfg.collectorUrl });
+      } catch (e) {
+        if (cfg.debug) console.error('[mk-sdk] init erro', e);
+      }
+    }
+
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', init);
+    } else {
+      init();
+    }
+
+    // ─── API pública ──────────────────────────────────────────────────────
+    const api = {
+      // try-on
+      open: tryon.open,
+      close: tryon.close,
+      isAvailable: tryon.isAvailable,
+      getAvailability: tryon.getAvailability,
+      onReady: tryon.onReady,
+      onClose: tryon.onClose,
+      onAddToCart: tryon.onAddToCart,
+      onProductLoaded: tryon.onProductLoaded,
+      onError: tryon.onError,
+      onInteraction: tryon.onInteraction,
+      onGenerationComplete: tryon.onGenerationComplete,
+      // meta
+      _version: '0.1.0',
+      _isMkSdk: true
+    };
+
+    if (typeof window !== 'undefined') {
+      window.mk = api;   // global único e canônico do mk-sdk
+    }
+  } catch (e) {
+    if (typeof console !== 'undefined') console.error('[mk-sdk] boot fatal', e);
+  }
+})();

package/src/platforms/generic.js

@@ -0,0 +1,41 @@
+// generic.js — fallback pra lojas sem plataforma com adapter dedicado.
+// SKU por sinais nativos (JSON-LD, microdata, Konfidency); cart = clique nativo.
+
+import { readJsonLd } from '../ecommerce/jsonld.js';
+
+export const id = 'generic';
+export function detect() { return true; }   // sempre casa (é o último recurso)
+
+export function resolveSku() {
+  const products = readJsonLd(['Product']);
+  if (products[0]) {
+    const p = products[0];
+    const s = p.sku || p.mpn || p.gtin13 || p.productID;
+    if (s) return { value: String(s), source: 'jsonld' };
+  }
+  try {
+    const el = document.querySelector('[itemprop="sku"]');
+    if (el) { const v = el.getAttribute('content') || (el.textContent || '').trim(); if (v) return { value: String(v), source: 'microdata' }; }
+  } catch (_) {}
+  try {
+    const kd = window.konfidencyData;
+    if (kd && kd.product && kd.product.variants && kd.product.variants[0])
+      return { value: String(kd.product.variants[0]), source: 'konfidency' };
+  } catch (_) {}
+  return null;
+}
+
+const ANCHOR = /(adicionar\s*(à|a|ao)?\s*(sacola|carrinho|cesta|bolsa))|adicionar ao carrinho|add to (cart|bag)|comprar agora/i;
+const ANCHOR_NEG = /continuar|como comprar|lista|desejos|favorito/i;
+
+// fallback universal: clica o botão de carrinho nativo (a loja resolve o resto)
+export async function addToCart() {
+  const els = document.querySelectorAll('button,[role=button],input[type=submit]');
+  for (const el of els) {
+    const t = (el.textContent || el.value || '').replace(/\s+/g, ' ').trim();
+    if (t && t.length < 40 && ANCHOR.test(t) && !ANCHOR_NEG.test(t)) {
+      try { el.click(); return { platform: 'native-click', clicked: t }; } catch (_) {}
+    }
+  }
+  return { platform: 'none', error: 'botão de carrinho nativo não encontrado' };
+}

package/src/platforms/hybris.js

@@ -0,0 +1,44 @@
+// hybris.js — TUDO da plataforma SAP Commerce / Hybris (ex: Marisa): detecção,
+// SKU (productCode da URL) e carrinho. Validado ao vivo na Marisa.
+
+export const id = 'hybris';
+export function detect() { return !!(window.ACC && window.ACC.config); }
+
+// o productCode da URL (/p/{code}) é o identificador do catálogo. O [itemprop=sku]
+// do Hybris é um código interno diferente — por isso o SKU vem da URL aqui.
+export function resolveSku() {
+  const m = (location.pathname || '').match(/\/p\/([^/?#]+)/);
+  if (m && m[1]) return { value: decodeURIComponent(m[1]), source: 'hybris/url' };
+  return null;
+}
+
+const norm = (s) => String(s == null ? '' : s).trim().toLowerCase();
+
+export async function addToCart({ size, quantity }) {
+  // cada tamanho carrega o productCode da variante em data-code
+  const els = [...document.querySelectorAll('.js-product-select-size, a[data-code], [class*="select-size"]')]
+    .filter((e) => e.getAttribute && e.getAttribute('data-code'));
+  let el = size ? els.find((e) => norm(e.textContent) === norm(size)) : null;
+  if (!el) el = els.find((e) => e.offsetParent !== null) || els[0];
+  const code = el && el.getAttribute('data-code');
+  if (!code) throw new Error('hybris: variante (data-code) não encontrada');
+
+  const form = document.getElementById('product--add-to-cart-form') || document.querySelector('form[action*="/cart/add"]');
+  const csrfEl = form && form.querySelector('[name="CSRFToken"]');
+  const csrf = csrfEl && csrfEl.value;
+  const action = (form && form.getAttribute('action')) || '/cart/add';
+  if (!csrf) throw new Error('hybris: CSRFToken não encontrado');
+
+  const body = new URLSearchParams();
+  body.set('productCodePost', code);
+  body.set('qty', String(quantity || 1));
+  body.set('CSRFToken', csrf);
+
+  const resp = await fetch(action, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'X-Requested-With': 'XMLHttpRequest' },
+    body: body.toString()
+  });
+  if (!resp.ok) throw new Error('hybris: ' + action + ' HTTP ' + resp.status);
+  return { platform: 'hybris', productCode: code, size: el.textContent.trim() };
+}