@prolibu-suite/cobalt-core 0.10.4 → 0.11.0

package/dist/collection/utils/gradientStops.js

@@ -0,0 +1,142 @@
+/**
+ * Matemática pura de co-gradient-bar y co-swatch-grid: parseo de colores
+ * (hex/rgb/rgba), interpolación entre paradas, CSS del degradado y la
+ * geometría puntero → posición. Sin DOM ni estado: se testea en el proyecto
+ * `unit` (node).
+ */
+import { luminanceRgb } from "./color";
+import { clamp, hexToRgb, rgbToHex } from "./hsv";
+/**
+ * Lee un color CSS a canales. Soporta hex de 3/4/6/8 dígitos (vía
+ * `hsv.hexToRgb`, único parser de hex del picker) y rgb()/rgba() (con comas
+ * o con la sintaxis `/ alpha`). Tokens (`var(--x)`) y nombres (`red`)
+ * devuelven null: el llamador decide cómo degradar.
+ */
+export function parseColor(color) {
+    var _a;
+    if (!color || typeof color !== 'string')
+        return null;
+    const s = color.trim();
+    if (s.startsWith('#')) {
+        const c = hexToRgb(s);
+        return c ? { r: c.r, g: c.g, b: c.b, a: (_a = c.a) !== null && _a !== void 0 ? _a : 1 } : null;
+    }
+    const m = /^rgba?\(\s*([^)]*?)\s*\)$/i.exec(s);
+    if (!m)
+        return null;
+    // "10, 20, 30, 0.5" · "10 20 30 / 25%" · "10 20 30"
+    const parts = m[1].split(/\s*[,/]\s*|\s+/).filter(Boolean);
+    if (parts.length < 3 || parts.length > 4)
+        return null;
+    const [r, g, b] = parts.slice(0, 3).map((p) => Number(p));
+    if ([r, g, b].some((v) => Number.isNaN(v)))
+        return null;
+    const a = parts[3] === undefined ? 1 : parseAlpha(parts[3]);
+    if (a === null)
+        return null;
+    return { r: clamp(r, 0, 255), g: clamp(g, 0, 255), b: clamp(b, 0, 255), a };
+}
+function parseAlpha(raw) {
+    const pct = raw.endsWith('%');
+    const n = Number(pct ? raw.slice(0, -1) : raw);
+    if (Number.isNaN(n))
+        return null;
+    return clamp(pct ? n / 100 : n, 0, 1);
+}
+const round = (n, decimals) => Math.round(n * 10 ** decimals) / 10 ** decimals;
+/** Opaco → `#rrggbb` (minúsculas, vía `hsv.rgbToHex`); con alpha → `rgba(r, g, b, a)`. */
+export function formatColor({ r, g, b, a }) {
+    if (a >= 1)
+        return rgbToHex({ r, g, b });
+    return `rgba(${Math.round(r)}, ${Math.round(g)}, ${Math.round(b)}, ${round(a, 3)})`;
+}
+/**
+ * El mismo color con alpha 1 (`#rrggbb`), para la mitad "sólida" del chip de
+ * un stop translúcido. Un color ilegible se devuelve tal cual.
+ */
+export function opaqueColor(color) {
+    const c = parseColor(color);
+    return c ? formatColor(Object.assign(Object.assign({}, c), { a: 1 })) : color;
+}
+const byPosition = (stops) => [...stops].sort((a, b) => a.position - b.position);
+/**
+ * Color que tiene el degradado en `position`: mezcla lineal (sRGB, con alpha)
+ * entre las dos paradas que la rodean. Fuera del rango devuelve el color del
+ * extremo. Si alguna parada vecina no se puede parsear, devuelve el string de
+ * la parada más cercana tal cual (no inventa un color).
+ */
+export function interpolateStopColor(stops, position) {
+    if (stops.length === 0)
+        return 'rgba(0, 0, 0, 0)';
+    const sorted = byPosition(stops);
+    const p = clamp(position, 0, 100);
+    if (p <= sorted[0].position)
+        return sorted[0].color;
+    const last = sorted[sorted.length - 1];
+    if (p >= last.position)
+        return last.color;
+    let i = 1;
+    while (sorted[i].position < p)
+        i++;
+    const from = sorted[i - 1];
+    const to = sorted[i];
+    const span = to.position - from.position;
+    const t = span === 0 ? 0 : (p - from.position) / span;
+    const nearest = t < 0.5 ? from : to;
+    const c0 = parseColor(from.color);
+    const c1 = parseColor(to.color);
+    if (!c0 || !c1)
+        return nearest.color;
+    return formatColor({
+        r: c0.r + (c1.r - c0.r) * t,
+        g: c0.g + (c1.g - c0.g) * t,
+        b: c0.b + (c1.b - c0.b) * t,
+        a: c0.a + (c1.a - c0.a) * t,
+    });
+}
+/** `linear-gradient(to right, …)` con las paradas ordenadas; sin paradas → `transparent`. */
+export function gradientCss(stops) {
+    if (stops.length === 0)
+        return 'transparent';
+    if (stops.length === 1) {
+        const { color } = stops[0];
+        return `linear-gradient(to right, ${color} 0%, ${color} 100%)`;
+    }
+    const parts = byPosition(stops).map((s) => `${s.color} ${clamp(s.position, 0, 100)}%`);
+    return `linear-gradient(to right, ${parts.join(', ')})`;
+}
+/** true si alguna parada tiene alpha < 1 (la barra necesita el damero debajo). */
+export function hasTransparentStop(stops) {
+    return stops.some((s) => {
+        const c = parseColor(s.color);
+        return !!c && c.a < 1;
+    });
+}
+/**
+ * Posición (0–100, entera) de un puntero sobre el track. `trackWidth` 0 (sin
+ * medir, display:none, jsdom) → 0, nunca NaN.
+ */
+export function positionFromPointer(clientX, trackLeft, trackWidth) {
+    if (trackWidth <= 0)
+        return 0;
+    return Math.round(clamp(((clientX - trackLeft) / trackWidth) * 100, 0, 100));
+}
+/** Paso de teclado: posición + delta, acotado a 0–100. */
+export function stepPosition(position, delta) {
+    return clamp(position + delta, 0, 100);
+}
+/**
+ * Swatch "claro" (necesita borde para no fundirse con el fondo): luminancia
+ * WCAG > 0,85 tras componer el alpha sobre blanco. Umbral distinto al
+ * `isLightColor` de `utils/color.ts` (0,4, pensado para elegir el color del
+ * texto), por eso vive aparte y no cambia aquel default.
+ */
+export function isLightSwatch(color) {
+    const c = parseColor(color);
+    if (!c)
+        return false;
+    // Compone sobre blanco y mide directo sobre los canales (sin re-codificar a
+    // hex — fix I-6): `luminanceRgb` acepta decimales.
+    const over = (v) => v * c.a + 255 * (1 - c.a);
+    return luminanceRgb({ r: over(c.r), g: over(c.g), b: over(c.b) }) > 0.85;
+}

package/dist/collection/utils/hsv.js

@@ -0,0 +1,114 @@
+/**
+ * Conversiones puras HSV ⇄ RGB ⇄ HEX para el picker de color del editor
+ * (`co-color-area` + `co-color-slider`).
+ *
+ * Convención de rangos (la misma que exponen los componentes):
+ *   h ∈ [0, 360)   s ∈ [0, 100]   v ∈ [0, 100]   r/g/b ∈ [0, 255]   a ∈ [0, 1]
+ *
+ * `hexToHsv` NO redondea: la ida y vuelta hex → hsv → hex solo es estable con
+ * los decimales (p.ej. #008ff0 es h=204.25, v=94.117…; redondeado a enteros
+ * vuelve como #0090f0). Quien muestre números redondea en la UI.
+ *
+ * Sin dependencias de DOM: corre en el proyecto `unit` (node) de vitest.
+ */
+/** Acota `n` a [min, max]. NaN cae a `min` para no propagar basura aguas abajo. */
+export function clamp(n, min, max) {
+    if (Number.isNaN(n))
+        return min;
+    return Math.min(max, Math.max(min, n));
+}
+/** Normaliza un tono a [0, 360): 360 → 0, −120 → 240. */
+function wrapHue(h) {
+    if (Number.isNaN(h))
+        return 0;
+    return ((h % 360) + 360) % 360;
+}
+/** HSV → RGB (0–255, redondeado). Algoritmo estándar por sectores de 60°. */
+export function hsvToRgb({ h, s, v }) {
+    const hue = wrapHue(h);
+    const sat = clamp(s, 0, 100) / 100;
+    const val = clamp(v, 0, 100) / 100;
+    const c = val * sat;
+    const x = c * (1 - Math.abs(((hue / 60) % 2) - 1));
+    const m = val - c;
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    if (hue < 60)
+        [r, g] = [c, x];
+    else if (hue < 120)
+        [r, g] = [x, c];
+    else if (hue < 180)
+        [g, b] = [c, x];
+    else if (hue < 240)
+        [g, b] = [x, c];
+    else if (hue < 300)
+        [r, b] = [x, c];
+    else
+        [r, b] = [c, x];
+    return {
+        r: Math.round((r + m) * 255),
+        g: Math.round((g + m) * 255),
+        b: Math.round((b + m) * 255),
+    };
+}
+/** RGB (0–255) → HSV sin redondear. El gris devuelve h=0, s=0 (nunca NaN). */
+export function rgbToHsv({ r, g, b }) {
+    const rr = clamp(r, 0, 255) / 255;
+    const gg = clamp(g, 0, 255) / 255;
+    const bb = clamp(b, 0, 255) / 255;
+    const max = Math.max(rr, gg, bb);
+    const min = Math.min(rr, gg, bb);
+    const d = max - min;
+    let h = 0;
+    if (d !== 0) {
+        if (max === rr)
+            h = 60 * (((gg - bb) / d) % 6);
+        else if (max === gg)
+            h = 60 * ((bb - rr) / d + 2);
+        else
+            h = 60 * ((rr - gg) / d + 4);
+        if (h < 0)
+            h += 360;
+    }
+    return { h, s: max === 0 ? 0 : (d / max) * 100, v: max * 100 };
+}
+const HEX_RE = /^#?([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+/**
+ * `#rgb` / `#rgba` / `#rrggbb` / `#rrggbbaa` (con o sin `#`, cualquier caja)
+ * → RGB. `a` viene en 0–1 (1 cuando el hex no trae alpha). `null` si no es
+ * un hex. Es el ÚNICO parser de hex del picker: `gradientStops.parseColor`
+ * delega acá su rama hex (fix I-6).
+ */
+export function hexToRgb(hex) {
+    if (typeof hex !== 'string')
+        return null;
+    const m = HEX_RE.exec(hex.trim());
+    if (!m)
+        return null;
+    let h = m[1];
+    // Forma corta (#rgb / #rgba): cada dígito se duplica.
+    if (h.length <= 4)
+        h = h.split('').map((ch) => ch + ch).join('');
+    const int = (i) => parseInt(h.slice(i, i + 2), 16);
+    return {
+        r: int(0),
+        g: int(2),
+        b: int(4),
+        a: h.length === 8 ? int(6) / 255 : 1,
+    };
+}
+/** RGB → `#rrggbb` en minúscula (el alpha, si viene, se omite). */
+export function rgbToHex({ r, g, b }) {
+    const part = (n) => Math.round(clamp(n, 0, 255)).toString(16).padStart(2, '0');
+    return `#${part(r)}${part(g)}${part(b)}`;
+}
+/** HSV → `#rrggbb`. */
+export function hsvToHex(hsv) {
+    return rgbToHex(hsvToRgb(hsv));
+}
+/** HEX → HSV sin redondear (ver nota de cabecera). `null` si no es un hex. */
+export function hexToHsv(hex) {
+    const rgb = hexToRgb(hex);
+    return rgb ? rgbToHsv(rgb) : null;
+}

package/dist/collection/utils/kbdI18n.js

@@ -0,0 +1,29 @@
+/**
+ * Diccionario embebido de `co-kbd` para las etiquetas de texto de los
+ * modificadores en plataformas sin teclas dedicadas (Windows/Linux): sin
+ * los glifos de Mac (⌘/⇧/⌥/⌃) el modificador se rotula con texto.
+ *
+ * Mismo patrón que `fileI18n.ts`: un mapa por locale + un getter. A
+ * diferencia de `fileI18n`, acá el locale no llega tipado por componente —
+ * `co-kbd` expone un `locale?: string` opcional (BCP-47, p.ej. "es-CO") y
+ * este util lo resuelve al lenguaje soportado más cercano, igual que
+ * `langFromLocale` en `fileI18n.ts`.
+ */
+const DICT = {
+    es: { ctrl: 'Ctrl', shift: 'Shift', alt: 'Alt', win: 'Win' },
+    en: { ctrl: 'Ctrl', shift: 'Shift', alt: 'Alt', win: 'Win' },
+    pt: { ctrl: 'Ctrl', shift: 'Shift', alt: 'Alt', win: 'Win' },
+};
+/** Map any BCP-47 locale (e.g. "es-CO") to a supported language; fallback 'en'. */
+export function langFromLocale(locale) {
+    const l = (locale || '').toLowerCase();
+    if (l.startsWith('es'))
+        return 'es';
+    if (l.startsWith('pt'))
+        return 'pt';
+    return 'en';
+}
+/** Resolve the built-in win-label strings for a locale. */
+export function getKbdStrings(locale) {
+    return DICT[langFromLocale(locale)];
+}

package/dist/collection/utils/positioning.js

@@ -10,9 +10,15 @@
  * Calculate top/left for a fixed-position panel relative to a trigger.
  */
 export function computePosition(triggerRect, panelRect, options) {
+    var _a, _b;
     const { offset, flip } = options;
     const viewportH = window.innerHeight;
     const viewportW = window.innerWidth;
+    const shift = (_a = options.shift) !== null && _a !== void 0 ? _a : 0;
+    // Task C10 (Fase 2 Cobalt): con `anchor`, TODA la matemática (flip incluido)
+    // se hace contra el rect del anchor en vez del trigger. Sin `anchorRect`,
+    // `referenceRect === triggerRect` — cero cambio de comportamiento.
+    const referenceRect = (_b = options.anchorRect) !== null && _b !== void 0 ? _b : triggerRect;
     let placement = options.placement;
     // Auto-flip if needed
     if (flip) {
@@ -21,29 +27,29 @@ export function computePosition(triggerRect, panelRect, options) {
         const isRight = placement.startsWith('right');
         const isLeft = placement.startsWith('left');
         if (isBottom) {
-            const spaceBelow = viewportH - triggerRect.bottom - offset;
-            const spaceAbove = triggerRect.top - offset;
+            const spaceBelow = viewportH - referenceRect.bottom - offset;
+            const spaceAbove = referenceRect.top - offset;
             if (spaceBelow < panelRect.height && spaceAbove > spaceBelow) {
                 placement = placement.replace('bottom', 'top');
             }
         }
         else if (isTop) {
-            const spaceAbove = triggerRect.top - offset;
-            const spaceBelow = viewportH - triggerRect.bottom - offset;
+            const spaceAbove = referenceRect.top - offset;
+            const spaceBelow = viewportH - referenceRect.bottom - offset;
             if (spaceAbove < panelRect.height && spaceBelow > spaceAbove) {
                 placement = placement.replace('top', 'bottom');
             }
         }
         else if (isRight) {
-            const spaceRight = viewportW - triggerRect.right - offset;
-            const spaceLeft = triggerRect.left - offset;
+            const spaceRight = viewportW - referenceRect.right - offset;
+            const spaceLeft = referenceRect.left - offset;
             if (spaceRight < panelRect.width && spaceLeft > spaceRight) {
                 placement = placement.replace('right', 'left');
             }
         }
         else if (isLeft) {
-            const spaceLeft = triggerRect.left - offset;
-            const spaceRight = viewportW - triggerRect.right - offset;
+            const spaceLeft = referenceRect.left - offset;
+            const spaceRight = viewportW - referenceRect.right - offset;
             if (spaceLeft < panelRect.width && spaceRight > spaceLeft) {
                 placement = placement.replace('left', 'right');
             }
@@ -58,29 +64,33 @@ export function computePosition(triggerRect, panelRect, options) {
     const isHorizontal = isRight || isLeft;
     if (isHorizontal) {
         if (isRight)
-            left = triggerRect.right + offset;
+            left = referenceRect.right + offset;
         else
-            left = triggerRect.left - panelRect.width - offset;
+            left = referenceRect.left - panelRect.width - offset;
         const align = placement.split('-')[1] || 'center';
         if (align === 'start')
-            top = triggerRect.top;
+            top = referenceRect.top;
         else if (align === 'end')
-            top = triggerRect.bottom - panelRect.height;
+            top = referenceRect.bottom - panelRect.height;
         else
-            top = triggerRect.top + (triggerRect.height - panelRect.height) / 2;
+            top = referenceRect.top + (referenceRect.height - panelRect.height) / 2;
+        // Eje cruzado de un placement horizontal (left*/right*) es vertical.
+        top += shift;
     }
     else {
         if (isTop)
-            top = triggerRect.top - panelRect.height - offset;
+            top = referenceRect.top - panelRect.height - offset;
         else
-            top = triggerRect.bottom + offset;
+            top = referenceRect.bottom + offset;
         const align = placement.split('-')[1] || 'center';
         if (align === 'start')
-            left = triggerRect.left;
+            left = referenceRect.left;
         else if (align === 'end')
-            left = triggerRect.right - panelRect.width;
+            left = referenceRect.right - panelRect.width;
         else
-            left = triggerRect.left + (triggerRect.width - panelRect.width) / 2;
+            left = referenceRect.left + (referenceRect.width - panelRect.width) / 2;
+        // Eje cruzado de un placement vertical (top*/bottom*) es horizontal.
+        left += shift;
     }
     // Clamp to viewport edges (4px margin)
     if (left < 4)
@@ -209,3 +219,19 @@ export function findScrollParents(start) {
     }
     return out;
 }
+/**
+ * ¿El ancla (trigger) se ve todavía? Tiene que tener caja y cortar el viewport Y
+ * cada uno de sus scrollers (`clipRects`, del más cercano al más lejano — lo que
+ * devuelve `findScrollParents`, medido). Basta con que UNO la recorte entera para
+ * que no se vea: el kebab de una card que el scroll de su columna sacó por arriba
+ * sigue dentro del viewport, pero ya no es visible.
+ *
+ * Asomada en un borde cuenta como visible: el panel todavía tiene de qué colgar.
+ */
+export function isAnchorVisible(anchor, clipRects) {
+    if (!anchor.width && !anchor.height)
+        return false;
+    const viewport = { top: 0, left: 0, bottom: window.innerHeight, right: window.innerWidth };
+    return [viewport, ...clipRects].every((clip) => anchor.bottom > clip.top && anchor.top < clip.bottom
+        && anchor.right > clip.left && anchor.left < clip.right);
+}

package/dist/collection/utils/rich-text-host.js

@@ -0,0 +1,109 @@
+/**
+ * Cableado común de los componentes que montan un editor de cobalt-rich-text
+ * (co-rich-text-editor y co-document-editor). Extraído del RTE sin cambiar su
+ * comportamiento (spec contracts-v2-contract-editor §4.4; caracterización en
+ * co-rich-text-editor.characterization.spec.tsx). El menú flotante NO vive acá.
+ */
+/** `features` llega como objeto (propiedad JS) o como JSON (atributo HTML). */
+export function parseFeatures(features) {
+    if (!features)
+        return undefined;
+    if (typeof features === 'string') {
+        try {
+            return JSON.parse(features);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    return features;
+}
+/** `value` puede ser JSON de ProseMirror o HTML; vacío = documento vacío. */
+export function parseEditorValue(v) {
+    if (!v)
+        return '';
+    try {
+        return JSON.parse(v);
+    }
+    catch (_a) {
+        return v;
+    }
+}
+/**
+ * Guarda anti-eco: el padre suele devolver por `value` lo mismo que el editor
+ * acaba de emitir (en JSON o en HTML). Re-aplicarlo reinicia el editor y el
+ * cursor salta: se ignora.
+ */
+export class EchoGuard {
+    constructor() {
+        this.json = null;
+        this.html = '';
+    }
+    /** Tras aplicar un valor externo (o al montar): ese valor pasa a ser el "último". */
+    seed(v) {
+        this.json = v;
+        this.html = '';
+    }
+    markEmitted(out) {
+        this.json = out.json ? JSON.stringify(out.json) : null;
+        this.html = out.html;
+    }
+    isEcho(incoming) {
+        return incoming === this.json || incoming === this.html;
+    }
+}
+/** Aplica un `value` externo sin emitir update. */
+export function applyExternalValue(editor, incoming) {
+    if (incoming === '' || incoming === null) {
+        editor.commands.clearContent(false);
+    }
+    else {
+        editor.commands.setContent(parseEditorValue(incoming), { emitUpdate: false });
+    }
+}
+/** Salida `{json, html, text}` del RTE. `sanitizeHtml` lo pone el componente (preset + features). */
+export function buildOutput(editor, sanitizeHtml) {
+    const empty = editor.isEmpty;
+    return {
+        json: empty ? null : editor.getJSON(),
+        html: empty ? '' : sanitizeHtml(editor.getHTML()),
+        text: editor.getText(),
+    };
+}
+/** Pasa el editor activo y el handler de imágenes a `co-rich-text-toolbar`. */
+export function syncToolbarEditor(toolbarEl, editor, imageUpload) {
+    if (toolbarEl && editor && toolbarEl.editor !== editor) {
+        toolbarEl.editor = editor;
+    }
+    if (toolbarEl) {
+        toolbarEl.imageUpload = imageUpload;
+    }
+}
+/**
+ * Marca cada contenedor de imagen con su modo (`data-image-layout`) para que
+ * apliquen las reglas del CSS, y limpia el posicionamiento absoluto heredado del
+ * modelo de página fija. El NodeView de resize nunca refleja cambios de attrs en
+ * el DOM: se lee del state y se escribe el atributo a mano.
+ */
+export function syncImageLayouts(editor) {
+    const view = editor.view;
+    editor.state.doc.descendants((node, pos) => {
+        var _a;
+        if (node.type.name !== 'image')
+            return true;
+        const dom = view.nodeDOM(pos);
+        const c = (((_a = dom === null || dom === void 0 ? void 0 : dom.closest) === null || _a === void 0 ? void 0 : _a.call(dom, '[data-resize-container]')) || dom);
+        if (!c)
+            return true;
+        const layout = node.attrs.imageLayout || 'inline';
+        c.dataset.imageLayout = layout;
+        c.style.position = '';
+        c.style.left = '';
+        c.style.top = '';
+        c.style.zIndex = '';
+        // El NodeView de resize fija `display: inline-flex` inline, que le gana al
+        // `display: block` del CSS en `center` / `full-width` (2026-09-17).
+        c.style.display = layout === 'center' || layout === 'full-width' ? '' : 'inline-flex';
+        return true;
+    });
+}

package/dist/collection/utils/richTextI18n.js

@@ -124,6 +124,21 @@ const DICT = {
         imageLayoutWrapRight: 'Wrap right',
         imageLayoutCenter: 'Center',
         imageLayoutFullWidth: 'Full width',
+        heading4: 'Heading 4',
+        headingAbbr4: 'H4',
+        field: 'Field',
+        fieldNamePlaceholder: 'Field name',
+        signature: 'Signature',
+        documentHeader: 'Header',
+        page: 'Page',
+        pageNumber: 'Page number',
+        confirmHeader: 'Confirm header',
+        zoom: 'Zoom',
+        zoomFit: 'Fit width',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Break text',
+        imageLayoutLabel: 'Image layout',
+        documentEditor: 'Document editor',
     },
     es: {
         bold: 'Negrita',
@@ -243,6 +258,21 @@ const DICT = {
         imageLayoutWrapRight: 'Ajustar a la derecha',
         imageLayoutCenter: 'Centrar',
         imageLayoutFullWidth: 'Ancho completo',
+        heading4: 'Encabezado 4',
+        headingAbbr4: 'Enc. 4',
+        field: 'Campo',
+        fieldNamePlaceholder: 'Nombre del campo',
+        signature: 'Firma',
+        documentHeader: 'Encabezado',
+        page: 'Página',
+        pageNumber: 'Número de página',
+        confirmHeader: 'Confirmar encabezado',
+        zoom: 'Zoom',
+        zoomFit: 'Ajustar al ancho',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Separar del texto',
+        imageLayoutLabel: 'Diseño de la imagen',
+        documentEditor: 'Editor de documento',
     },
     pt: {
         bold: 'Negrito',
@@ -362,6 +392,21 @@ const DICT = {
         imageLayoutWrapRight: 'Ajustar à direita',
         imageLayoutCenter: 'Centralizar',
         imageLayoutFullWidth: 'Largura total',
+        heading4: 'Título 4',
+        headingAbbr4: 'T. 4',
+        field: 'Campo',
+        fieldNamePlaceholder: 'Nome do campo',
+        signature: 'Assinatura',
+        documentHeader: 'Cabeçalho',
+        page: 'Página',
+        pageNumber: 'Número da página',
+        confirmHeader: 'Confirmar cabeçalho',
+        zoom: 'Zoom',
+        zoomFit: 'Ajustar à largura',
+        zoomActual: '100 %',
+        imageLayoutBreak: 'Separar do texto',
+        imageLayoutLabel: 'Layout da imagem',
+        documentEditor: 'Editor de documento',
     },
 };
 /** Map any BCP-47 locale (e.g. "es-CO") to a supported language; fallback 'en'. */

package/dist/collection/utils/submenu.js

@@ -8,11 +8,31 @@ export function sideOfPlacement(placement) {
     const side = placement.split('-')[0];
     return side === 'left' || side === 'right' ? side : null;
 }
+/** Atributo con el que `co-menu` publica hacia sus ítems si su panel terminó
+ *  abriendo hacia ARRIBA (`up`) o hacia abajo (`down`), post-flip. */
+export const MENU_DIRECTION_ATTR = 'menu-direction';
+/** Dirección vertical de un placement ya resuelto del menú raíz. */
+export function menuDirectionOfPlacement(placement) {
+    return placement.split('-')[0] === 'top' ? 'up' : 'down';
+}
 /** Placement que debe pedir un submenú, dado el lado al que resolvió el submenú
  *  de su ancestro. Sin ancestro (primer nivel) mantiene el comportamiento
- *  histórico: a la derecha, y que el flip decida. */
-export function submenuPlacement(parentSide) {
-    return parentSide === 'left' ? 'left-start' : 'right-start';
+ *  histórico: a la derecha, y que el flip decida.
+ *
+ *  `opensUp`: el menú raíz abrió hacia ARRIBA (trigger al pie: barra de acciones,
+ *  footer). Entonces el submenú se alinea por el BORDE INFERIOR de su fila
+ *  (`-end`) y crece hacia arriba, como el menú del que sale. Con `-start` crecía
+ *  hacia abajo y tapaba el trigger y la barra (Exportar selección → Datos,
+ *  tarea QA #12). `flip`/`shift` del popover siguen actuando si no cabe. */
+export function submenuPlacement(parentSide, opensUp = false) {
+    const align = opensUp ? 'end' : 'start';
+    return parentSide === 'left' ? `left-${align}` : `right-${align}`;
+}
+/** ¿El `co-menu` que contiene a este ítem abrió hacia arriba? Los ítems (y los
+ *  anidados) son hijos de light DOM del co-menu, así que `closest` lo alcanza. */
+export function menuOpensUp(el) {
+    var _a;
+    return ((_a = el.closest('co-menu')) === null || _a === void 0 ? void 0 : _a.getAttribute(MENU_DIRECTION_ATTR)) === 'up';
 }
 /**
  * Lado heredado del `co-menu-item` ancestro más cercano, o null si no hay (o si

package/dist/collection/utils/swatchGridI18n.js

@@ -0,0 +1,14 @@
+/**
+ * Diccionario de strings de co-swatch-grid (aria labels). Misma estrategia
+ * que carouselI18n/dateI18n: es/en/pt resueltos por la prop `locale`.
+ */
+import { langFromLocale } from "./dateI18n";
+const DICT = {
+    es: { gridLabel: 'Colores' },
+    en: { gridLabel: 'Colors' },
+    pt: { gridLabel: 'Cores' },
+};
+/** Resuelve los strings integrados para un locale. */
+export function getSwatchGridStrings(locale) {
+    return DICT[langFromLocale(locale)];
+}

package/dist/collection/utils/test/fake-block-layout.js

@@ -0,0 +1,41 @@
+/**
+ * Layout de bloques simulado para specs en jsdom (que no tiene layout): cada
+ * elemento mide lo que diga `heightOf` (o su `style.height`, o la suma de sus
+ * hijos) y se apila bajo sus hermanos anteriores. `offsetParent` = padre.
+ * Devuelve la función que restaura los descriptores originales.
+ */
+export function installFakeBlockLayout(heightOf) {
+    const proto = HTMLElement.prototype;
+    const keys = ['offsetTop', 'offsetHeight', 'offsetParent'];
+    const saved = keys.map((k) => [k, Object.getOwnPropertyDescriptor(proto, k)]);
+    const height = (el) => {
+        const own = heightOf(el);
+        if (own !== undefined)
+            return own;
+        if (el.style.height)
+            return parseFloat(el.style.height) || 0;
+        return Array.from(el.children).reduce((sum, c) => sum + height(c), 0);
+    };
+    Object.defineProperty(proto, 'offsetHeight', { configurable: true, get() { return height(this); } });
+    Object.defineProperty(proto, 'offsetParent', { configurable: true, get() { return this.parentElement; } });
+    Object.defineProperty(proto, 'offsetTop', {
+        configurable: true,
+        get() {
+            let top = 0;
+            let s = this.previousElementSibling;
+            while (s) {
+                top += height(s);
+                s = s.previousElementSibling;
+            }
+            return top;
+        },
+    });
+    return () => {
+        saved.forEach(([k, d]) => {
+            if (d)
+                Object.defineProperty(proto, k, d);
+            else
+                delete proto[k];
+        });
+    };
+}