Merge: el ensayo de publicar cuenta todos los precios propios, no una muestra

Trae a main el arreglo del dry_run (la Edge devuelve el TOTAL y la lista
completa ordenada por diferencia) y la pantalla que lo ensena: tabla con
producto, canal, base, precio que se publica y delta; ocho visibles y
"y X mas"; mensaje en positivo cuando no hay ninguno.

hubrise-catalog-publish v48 ya esta desplegada y ACTIVE desde antes de
esta fusion: la Edge no depende del merge. Lo que el merge desbloquea es
el bundle OTA, para que el panel deje de leer el formato viejo.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vy4yW6xBAtXcaSGgKybquB

Author: claude

src/modules/kitchen/pages/KitchenMenuPage.tsx

@@ -17,6 +17,7 @@ import { useEffect, useMemo, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
 import { Search, ChevronDown, ChevronRight, CircleDashed, CheckCircle2, AlertTriangle, ChefHat, Clock, UtensilsCrossed, Package, Link2Off, Link2, Plus, FolderPlus, ArrowRightLeft, X, Undo2, Info, ArrowUp, ArrowDown, Trash2, UploadCloud, Loader2, Sparkles, PackagePlus, ScanSearch } from 'lucide-react'
 import { useActiveAccount } from '@/modules/multitenancy/hooks/useActiveAccount'
+import { fmtMoney } from '@/lib/format'
 import {
   listBrandsWithCatalog,
   listCategoriesWithProducts,
@@ -59,6 +60,24 @@ function formatPct(value: number | null): string {
   return `${Math.round(value)}%`
 }
 
+// Cuántos precios se enseñan en el ensayo. El TOTAL siempre se dice aparte;
+// esto solo acota la tabla para que el modal siga siendo legible.
+const PRECIOS_VISIBLES = 8
+
+// Slug de canal -> nombre de cara a quien mira.
+const CANAL_NOMBRE: Record<string, string> = {
+  glovo: 'Glovo', justeat: 'Just Eat', uber: 'Uber Eats', deliveroo: 'Deliveroo',
+}
+function canalBonito(slug: string): string {
+  return CANAL_NOMBRE[slug] ?? slug
+}
+
+// HubRise manda "13.50 EUR"; aquí se lee "13,50 €".
+function precioBonito(v: string | undefined): string {
+  const n = parseFloat(String(v ?? '').split(' ')[0])
+  return Number.isFinite(n) ? fmtMoney(n) : (v ?? '—')
+}
+
 export default function KitchenMenuPage() {
   const { activeAccountId, accountsLoading } = useActiveAccount()
   const navigate = useNavigate()
@@ -1015,32 +1034,52 @@ export default function KitchenMenuPage() {
                   <div className="text-xs text-gray-500 mt-0.5">
                     {t.productos} producto(s){t.location_id ? '' : ' · sin local asociado en la conexión'}
                   </div>
-                  {(() => {
-                    const conOverride = t.precios.filter((p) => (p.price_overrides?.length ?? 0) > 0)
-                    if (conOverride.length === 0) {
-                      return <div className="text-xs text-gray-400 mt-2">Sin precios propios por canal en la muestra.</div>
-                    }
-                    return (
-                      <div className="mt-2">
-                        <div className="text-xs font-medium text-gray-500 mb-1">Precios propios por canal</div>
-                        <ul className="text-xs space-y-0.5">
-                          {conOverride.map((p) => (
-                            <li key={p.ref} className="flex flex-wrap gap-x-2">
-                              <span className="font-mono text-gray-600">{p.ref}</span>
-                              <span className="text-gray-400">base {p.price}</span>
-                              {(p.price_overrides ?? []).map((o, i) => (
-                                <span key={i} className="text-gray-800">
-                                  · <span className="font-medium">{o.variant_refs.join(', ')}</span> {o.price}
-                                </span>
-                              ))}
-                            </li>
-                          ))}
-                        </ul>
+                  {/* LOS PRECIOS QUE CAMBIAN. El total va primero y sale del
+                      total, no de lo que se enseñe: una pantalla de
+                      confirmación nunca describe una muestra. */}
+                  {(t.precios_propios_total ?? 0) === 0 ? (
+                    <div className="text-xs text-gray-600 mt-2">
+                      Este catálogo se publica con los <span className="font-medium">precios base</span>:
+                      ningún precio propio por canal.
+                    </div>
+                  ) : (
+                    <div className="mt-2">
+                      <div className="text-xs font-medium text-gray-900 mb-1">
+                        {t.precios_propios_total} precio{t.precios_propios_total === 1 ? '' : 's'} propio{t.precios_propios_total === 1 ? '' : 's'} por canal
+                        <span className="font-normal text-gray-500"> · se publican distintos del base</span>
                       </div>
-                    )
-                  })()}
-                  {t.precios_truncados > 0 && (
-                    <div className="text-xs text-gray-400 mt-1">…y {t.precios_truncados} producto(s) más, no mostrados.</div>
+                      <table className="w-full text-xs">
+                        <thead>
+                          <tr className="text-gray-500">
+                            <th className="text-left font-medium py-0.5">Producto</th>
+                            <th className="text-left font-medium">Canal</th>
+                            <th className="text-right font-medium">Base</th>
+                            <th className="text-right font-medium">Se publica</th>
+                            <th className="text-right font-medium">Δ</th>
+                          </tr>
+                        </thead>
+                        <tbody>
+                          {(t.precios_propios ?? []).slice(0, PRECIOS_VISIBLES).map((c, i) => (
+                            <tr key={`${c.ref}-${i}`} className="border-t border-gray-100">
+                              <td className="py-0.5 pr-2 text-gray-800">{c.nombre}</td>
+                              <td className="pr-2 text-gray-600">{c.canales.map(canalBonito).join(', ')}</td>
+                              <td className="text-right tabular-nums text-gray-500">{precioBonito(c.base)}</td>
+                              <td className="text-right tabular-nums font-medium text-gray-900">{precioBonito(c.se_publica)}</td>
+                              <td className={`text-right tabular-nums font-medium ${
+                                c.delta_pct === null ? 'text-gray-400'
+                                  : c.delta_pct < 0 ? 'text-red-600' : 'text-green-700'}`}>
+                                {c.delta_pct === null ? '—' : `${c.delta_pct > 0 ? '+' : ''}${c.delta_pct} %`}
+                              </td>
+                            </tr>
+                          ))}
+                        </tbody>
+                      </table>
+                      {(t.precios_propios_total ?? 0) > PRECIOS_VISIBLES && (
+                        <div className="text-xs text-gray-500 mt-1">
+                          y {(t.precios_propios_total ?? 0) - PRECIOS_VISIBLES} más.
+                        </div>
+                      )}
+                    </div>
                   )}
                 </div>
               ))}

src/modules/kitchen/services/catalogPublishService.ts

@@ -44,11 +44,17 @@ export interface PublishResult {
   targets: PublishTarget[]
 }
 
-/** Un precio del ensayo: el del sku y, si los hay, los propios por canal. */
-export interface DryRunPrice {
+/**
+ * Un precio propio por canal que CAMBIA respecto al base, tal y como se
+ * publicaría. Precios en el formato de HubRise ("13.50 EUR").
+ */
+export interface DryRunPriceChange {
   ref: string
-  price: string
-  price_overrides: Array<{ variant_refs: string[]; price: string }> | null
+  nombre: string
+  canales: string[]      // slugs de canal: glovo | justeat | uber…
+  base: string
+  se_publica: string
+  delta_pct: number | null
 }
 
 /** Un catálogo de destino, tal y como lo devuelve el ensayo. */
@@ -57,8 +63,15 @@ export interface DryRunTarget {
   connection_name: string
   location_id: string | null
   productos: number
-  precios: DryRunPrice[]
-  precios_truncados: number
+  /**
+   * TOTAL, no lo que se enseñe. Una confirmación nunca describe una muestra.
+   * Opcionales a propósito: la OTA llega por estación, así que un panel puede
+   * hablar un rato con un Edge que todavía no los manda. La UI lo tolera en
+   * vez de reventar.
+   */
+  precios_propios_total?: number
+  /** Completa y ya ordenada por diferencia descendente (la ordena el Edge). */
+  precios_propios?: DryRunPriceChange[]
 }
 
 export interface DryRunResult {

supabase/functions/_shared/hubriseSku.ts

@@ -20,24 +20,36 @@
 // stock 0/null). Si cualquiera de los dos calcula el ref de otra forma, el
 // namespacing deja de servir — por eso vive en un solo fichero compartido.
 
+// Rango U+0300..U+036F = marcas diacriticas combinantes: lo que deja NFD tras
+// separar el acento de su letra.
+//
+// Se expresa con CODIGOS NUMERICOS, no con los caracteres en crudo ni con un
+// escape dentro de una expresion regular literal. Los caracteres en crudo son
+// INVISIBLES en el editor y en cualquier copia; y el escape no sobrevive al
+// desplegador, que viaja por JSON y decodifica los escapes antes de escribir
+// el fichero — paso en la v45, y volvio a pasar en la v46 y la v47 aun
+// mandandolo doblado. Con codigos el fichero es ASCII puro en esta parte: no
+// hay nada que un transporte pueda reinterpretar, y desplegado y repo salen
+// identicos byte a byte siempre. Mismo rango, misma semantica.
+const CM_MIN = 0x300;
+const CM_MAX = 0x36f;
+
+// Quita los acentos: descompone (NFD) y descarta las marcas combinantes.
+// Equivalente exacto a .normalize("NFD").replace(/[U+0300-U+036F]/g, "").
+function sinAcentos(s: string): string {
+  let out = "";
+  for (const ch of s.normalize("NFD")) {
+    const cp = ch.codePointAt(0) ?? 0;
+    if (cp >= CM_MIN && cp <= CM_MAX) continue;
+    out += ch;
+  }
+  return out;
+}
+
 // Sanea un fragmento para ref de SKU de HubRise: alfanumérico + _ - : (evita
 // espacios/acentos/símbolos que puedan romper el ref o el parseo de HubRise).
 function sanitizeRefPart(s: string): string {
-  // \u0300-\u036f = marcas diacriticas combinantes. Escritas con escapes y no
-  // con los caracteres literales a proposito: son INVISIBLES en el editor y en
-  // cualquier copia, y un despliegue que las pierda romperia el saneo de refs
-  // sin que nadie lo viera. Mismo rango, misma semantica.
-  //
-  // OJO al comparar bytes con lo desplegado (19/08, v45): la copia que corre en
-  // Supabase lleva los caracteres LITERALES, no estos escapes, porque el
-  // desplegador va por JSON y decodifico los \uXXXX al mandarlos. Es la MISMA
-  // expresion y es la forma que llevaba en produccion desde la v1; la unica
-  // diferencia es de escritura. Se alineara en el proximo despliegue de esta
-  // funcion. Si alguien diffea v45 contra el repo, este es el unico fichero
-  // que sale distinto, y estas cuatro lineas mas.
-  const COMBINING_MARKS = /[\u0300-\u036f]/g;
-  return s
-    .normalize("NFD").replace(COMBINING_MARKS, "") // quita acentos
+  return sinAcentos(s)
     .toLowerCase()
     .replace(/[^a-z0-9_-]+/g, "-")
     .replace(/-+/g, "-")

supabase/functions/hubrise-catalog-publish/index.ts

@@ -795,15 +795,55 @@ Deno.serve(async (req: Request) => {
     // catálogo de destino y los precios ya resueltos por local, que es lo que
     // hay que mirar antes de tocar un escaparate vivo.
     if (dryRun) {
+      // Un precio propio por canal, con su base y su delta, listo para ensenar.
+      const eurNum = (v: unknown): number => parseFloat(String(v ?? "0").split(" ")[0]) || 0;
+      const cambiosDe = (prods: Array<Record<string, unknown>>): Array<Record<string, unknown>> => {
+        const out: Array<Record<string, unknown>> = [];
+        for (const p of prods) {
+          const sku = ((p.skus as Array<Record<string, unknown>>) ?? [])[0] ?? {};
+          const base = sku.price as string | undefined;
+          for (const o of ((sku.price_overrides as Array<Record<string, unknown>>) ?? [])) {
+            const b = eurNum(base);
+            const n = eurNum(o.price);
+            out.push({
+              ref: p.ref,
+              nombre: p.name,
+              canales: (o.variant_refs as string[]) ?? [],
+              base,
+              se_publica: o.price,
+              delta_pct: b === 0 ? null : Math.round(((n - b) / b) * 100),
+            });
+          }
+        }
+        // Mayor diferencia primero, calculada sobre el TOTAL y no sobre lo que
+        // se acabe ensenando.
+        out.sort((a, b) => Math.abs(Number(b.delta_pct ?? 0)) - Math.abs(Number(a.delta_pct ?? 0)));
+        return out;
+      };
       const preview = publishTargets.map((t) => {
         const prods = productsPayloadFor(t.locationId);
+        const cambios = cambiosDe(prods);
         return {
           external_catalog_id: t.catalogId,
           connection_name: t.connName,
           location_id: t.locationId,
           productos: prods.length,
-          // Muestra acotada: publicar entero son cientos de líneas y aquí lo
-          // que importa es si el PRECIO es el del local o el de la marca.
+          // ── LOS PRECIOS QUE CAMBIAN, TODOS Y CONTADOS (19/08) ───
+          // Antes esto leia p.price y p.price_overrides. El precio NO vive en
+          // el producto: vive en su SKU (p.skus[0], ver donde se monta arriba).
+          // Los dos salian undefined SIEMPRE, para todas las marcas, asi que el
+          // ensayo decia "sin precios propios" aunque hubiera trece. No era la
+          // muestra: era el nivel equivocado, y ampliar la muestra no habria
+          // arreglado nada.
+          //
+          // Ahora se devuelve el TOTAL y la lista COMPLETA, ordenada por la
+          // diferencia mas grande primero. La pantalla decide cuantos ensena,
+          // pero el numero y el orden salen del total: una pantalla de
+          // confirmacion nunca describe una muestra.
+          precios_propios_total: cambios.length,
+          precios_propios: cambios,
+          // Se conservan por compatibilidad con paneles que aun no hayan
+          // recibido la OTA: leen `precios` y reventarian si desapareciera.
           precios: prods.slice(0, 25).map((p) => ({
             ref: p.ref,
             price: p.price,