@asteby/metacore-runtime-react 45.0.0 → 45.3.0

package/src/business/return.ts

@@ -0,0 +1,181 @@
+// Devolución de mercancía (ReturnWizard: POS, Pedido, Factura, RMA, OT, devolución
+// a proveedor). Lógica pura, sin endpoints: cada consumidor cablea el envío.
+// Flujo (benchmark §8.2): renglones → condición y destino → recepción → reembolso o NC.
+import { roundMoney, toAmount } from './format'
+import { validateRefund, type RefundAllocation, type RefundDestinationOption } from './refund'
+
+/** Estado físico de lo que regresa. */
+export type ReturnCondition = 'sellable' | 'defective'
+/** A dónde va la mercancía: stock vendible, merma o garantía (reclamo al proveedor). */
+export type ReturnStockDestination = 'stock' | 'scrap' | 'warranty'
+
+export const RETURN_CONDITION_DESTINATIONS: Record<ReturnCondition, ReturnStockDestination[]> = {
+    sellable: ['stock'],
+    defective: ['scrap', 'warranty'],
+}
+
+/** Destino por defecto de una condición (vendible → stock, defectuoso → merma). */
+export function defaultStockDestination(condition: ReturnCondition): ReturnStockDestination {
+    return RETURN_CONDITION_DESTINATIONS[condition][0]
+}
+
+/** Renglón devolvible: lo vendido menos lo ya devuelto. */
+export interface ReturnableLine {
+    key: string
+    product_id?: string
+    description: string
+    sold: number
+    alreadyReturned?: number
+    /** Precio unitario neto de descuento tal como se vendió (congelado). */
+    unit_price: number
+    /** Fracción (0.16). */
+    tax_rate?: number
+}
+
+export interface ReturnLineChoice {
+    quantity: number
+    condition: ReturnCondition
+    destination: ReturnStockDestination
+}
+
+export type ReturnChoices = Record<string, ReturnLineChoice>
+
+export function returnableQty(l: ReturnableLine): number {
+    return Math.max(0, roundMoney(l.sold - (l.alreadyReturned ?? 0), 4))
+}
+
+export interface ReturnTotals {
+    base: number
+    tax: number
+    total: number
+    goodsLines: number
+}
+
+export function computeReturnTotals(lines: ReturnableLine[], choices: ReturnChoices): ReturnTotals {
+    let base = 0
+    let tax = 0
+    let goodsLines = 0
+    for (const l of lines) {
+        const c = choices[l.key]
+        const q = c ? toAmount(c.quantity) : 0
+        if (q <= 0) continue
+        goodsLines += 1
+        const b = roundMoney(q * l.unit_price)
+        base += b
+        tax += roundMoney(b * (l.tax_rate ?? 0))
+    }
+    base = roundMoney(base)
+    tax = roundMoney(tax)
+    return { base, tax, total: roundMoney(base + tax), goodsLines }
+}
+
+/**
+ * Relación SAT (c_TipoRelacion) de la NC: 03 «devolución de mercancía» si regresan
+ * renglones con producto; 01 «nota de crédito de los documentos relacionados» si es
+ * solo ajuste de importe. Misma regla que aplica el backend al proyectar la NC.
+ */
+export function creditNoteRelation(lines: ReturnableLine[], choices: ReturnChoices): '01' | '03' {
+    return lines.some((l) => !!l.product_id && toAmount(choices[l.key]?.quantity) > 0) ? '03' : '01'
+}
+
+export interface ReturnValidation {
+    errors: Record<string, string>
+    form?: string
+    valid: boolean
+}
+
+export function validateReturnChoices(lines: ReturnableLine[], choices: ReturnChoices, reason?: string, requireReason = true): ReturnValidation {
+    const errors: Record<string, string> = {}
+    let any = false
+    for (const l of lines) {
+        const c = choices[l.key]
+        const q = c ? toAmount(c.quantity) : 0
+        if (q === 0) continue
+        if (q < 0) errors[`${l.key}.quantity`] = 'La cantidad no puede ser negativa'
+        else if (q > returnableQty(l)) errors[`${l.key}.quantity`] = `Máximo ${returnableQty(l)} por devolver`
+        else any = true
+        if (c && !RETURN_CONDITION_DESTINATIONS[c.condition]?.includes(c.destination)) {
+            errors[`${l.key}.destination`] = 'Ese destino no aplica a la condición elegida'
+        }
+    }
+    let form: string | undefined
+    if (!any && Object.keys(errors).length === 0) form = 'Elige al menos un renglón a devolver'
+    else if (requireReason && !(reason ?? '').trim()) form = 'Indica el motivo de la devolución'
+    return { errors, form, valid: !form && Object.keys(errors).length === 0 }
+}
+
+/** Pasos visibles. Sin almacén, «Recibir» es un paso del mismo asistente (PIT-021). */
+export type ReturnStep = 'lines' | 'condition' | 'receive' | 'refund'
+
+export function returnSteps(opts: { warehouseConnected: boolean }): ReturnStep[] {
+    // Con almacén, la recepción la confirma almacén fuera del asistente: no es paso.
+    return opts.warehouseConnected ? ['lines', 'condition', 'refund'] : ['lines', 'condition', 'receive', 'refund']
+}
+
+export interface ReturnSubmitPayload {
+    reason: string
+    notes?: string
+    /** true cuando el asistente confirmó la recepción (sin almacén). */
+    received: boolean
+    lines: { key: string; product_id?: string; quantity: number; condition: ReturnCondition; destination: ReturnStockDestination }[]
+    refund: RefundAllocation[]
+    /** Presente solo si el reembolso incluye una NC CFDI. */
+    credit_note?: { relation: '01' | '03' }
+    totals: ReturnTotals
+}
+
+/** Única puerta de salida hacia el backend: solo renglones con cantidad > 0. */
+export function serializeReturn(args: {
+    lines: ReturnableLine[]
+    choices: ReturnChoices
+    reason: string
+    notes?: string
+    received: boolean
+    refund: RefundAllocation[]
+}): ReturnSubmitPayload {
+    const lines = args.lines
+        .filter((l) => toAmount(args.choices[l.key]?.quantity) > 0)
+        .map((l) => {
+            const c = args.choices[l.key]
+            return { key: l.key, ...(l.product_id ? { product_id: l.product_id } : {}), quantity: toAmount(c.quantity), condition: c.condition, destination: c.destination }
+        })
+    const notes = (args.notes ?? '').trim()
+    return {
+        reason: args.reason.trim(),
+        ...(notes ? { notes } : {}),
+        received: args.received,
+        lines,
+        refund: args.refund.map((a) => ({ ...a, amount: roundMoney(a.amount) })),
+        ...(args.refund.some((a) => a.kind === 'credit_note') ? { credit_note: { relation: creditNoteRelation(args.lines, args.choices) } } : {}),
+        totals: computeReturnTotals(args.lines, args.choices),
+    }
+}
+
+/** Valida el paso de reembolso contra el total de la devolución. */
+export function validateReturnRefund(total: number, refund: RefundAllocation[], options?: RefundDestinationOption[]) {
+    return validateRefund(total, refund, options)
+}
+
+// ---- Estados de la RMA ---------------------------------------------------------
+// Borrador → Autorizada → Recibida (total o parcial) → Liquidada → Cerrada, y
+// Rechazada o Cancelada con motivo obligatorio (benchmark §8.2).
+export type RmaState = 'draft' | 'authorized' | 'received' | 'settled' | 'closed' | 'rejected' | 'cancelled'
+
+export const RMA_TRANSITIONS: Record<RmaState, RmaState[]> = {
+    draft: ['authorized', 'rejected', 'cancelled'],
+    authorized: ['received', 'rejected', 'cancelled'],
+    received: ['settled', 'cancelled'],
+    settled: ['closed'],
+    closed: [],
+    rejected: [],
+    cancelled: [],
+}
+
+/** Estados a los que se llega con motivo obligatorio. */
+export const RMA_REASON_REQUIRED: RmaState[] = ['rejected', 'cancelled']
+
+export function canTransitionRma(from: RmaState, to: RmaState, reason?: string): { ok: boolean; error?: string } {
+    if (!RMA_TRANSITIONS[from]?.includes(to)) return { ok: false, error: `No se puede pasar de ${from} a ${to}` }
+    if (RMA_REASON_REQUIRED.includes(to) && !(reason ?? '').trim()) return { ok: false, error: 'Indica el motivo' }
+    return { ok: true }
+}

package/src/business/use-async-search.ts

@@ -0,0 +1,43 @@
+import { useEffect, useState } from 'react'
+import { useDebouncedValue } from '../use-debounced-value'
+
+/** Búsqueda async con debounce y cancelación. `search` debe ser estable (useCallback). */
+export function useAsyncSearch<T>(
+    query: string,
+    search: (q: string, signal: AbortSignal) => Promise<T[]>,
+    opts: { minChars?: number; delay?: number } = {},
+): { results: T[]; loading: boolean; error: boolean } {
+    const { minChars = 2, delay = 250 } = opts
+    const q = useDebouncedValue(query.trim(), delay)
+    const [results, setResults] = useState<T[]>([])
+    const [loading, setLoading] = useState(false)
+    const [error, setError] = useState(false)
+
+    useEffect(() => {
+        if (q.length < minChars) {
+            setResults([])
+            setLoading(false)
+            setError(false)
+            return
+        }
+        const ctrl = new AbortController()
+        setLoading(true)
+        setError(false)
+        search(q, ctrl.signal)
+            .then((rows) => {
+                if (!ctrl.signal.aborted) setResults(rows)
+            })
+            .catch(() => {
+                if (!ctrl.signal.aborted) {
+                    setResults([])
+                    setError(true)
+                }
+            })
+            .finally(() => {
+                if (!ctrl.signal.aborted) setLoading(false)
+            })
+        return () => ctrl.abort()
+    }, [q, search, minChars])
+
+    return { results, loading, error }
+}

package/src/document/__tests__/document-page.test.tsx

@@ -0,0 +1,107 @@
+// @vitest-environment happy-dom
+//
+// DocumentPage: dos badges independientes con texto explícito, 1 primaria +
+// secundarias visibles, destructiva separada y bloqueada con motivo, botones
+// inteligentes con contador y pestaña «records» desde una fuente.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render, screen, fireEvent, waitFor } from '@testing-library/react'
+
+vi.mock('react-i18next', () => ({
+    useTranslation: () => ({ t: (k: string, o?: any) => o?.defaultValue ?? k }),
+}))
+vi.mock('../../dynamic-icon', () => ({ DynamicIcon: () => null }))
+
+import { DocumentPage } from '../document-page'
+import { ApiProvider, type ApiClient } from '../../api-context'
+import type { DocumentPageRegistration } from '../registry'
+
+afterEach(cleanup)
+
+const registration: DocumentPageRegistration = {
+    spec: {
+        model: 'invoices',
+        title: '{{number}}',
+        statuses: [
+            {
+                id: 'fiscal',
+                label: 'Estado fiscal',
+                field: '$.fiscal',
+                states: [{ value: 'stamped', label: 'Timbrada', tone: 'success' }],
+            },
+            {
+                id: 'billing',
+                label: 'Estado de cobro',
+                field: '$.billing',
+                states: [{ value: 'partial', label: 'Parcial', tone: 'caution' }],
+            },
+        ],
+        metrics: [{ label: 'Total', path: 'total', format: 'money' }],
+        actions: [
+            { key: 'pay', label: 'Registrar pago' },
+            { key: 'send', label: 'Enviar' },
+            { key: 'pdf', label: 'Descargar PDF', openUrl: '{{$.pdf}}' },
+            {
+                key: 'cancel',
+                label: 'Solicitar cancelación',
+                destructive: true,
+                blockedWhen: { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'Cancela primero los REP' },
+            },
+        ],
+        layouts: [{ when: { field: '$.fiscal', op: 'eq', value: 'stamped' }, layout: { primary: 'pay', secondary: ['send', 'pdf'], destructive: ['cancel'] } }],
+        smartButtons: [{ key: 'reps', label: 'REP', source: 'reps', tab: 'reps' }],
+        sources: [{ key: 'reps', model: 'fiscal_documents', foreignKey: 'source_id' }],
+        tabs: [
+            { key: 'reps', label: 'Pagos y REP', kind: 'records', source: 'reps', columns: [{ label: 'UUID', path: 'fiscal_uuid' }] },
+        ],
+    },
+    derive: () => ({ fiscal: 'stamped', billing: 'partial', pdf: 'https://x/y.pdf' }),
+}
+
+function setup(onAction = vi.fn()) {
+    const api = {
+        get: vi.fn().mockResolvedValue({ data: { success: true, data: [{ id: 'r1', fiscal_uuid: 'REP-UUID-1' }] } }),
+    } as unknown as ApiClient
+    render(
+        <ApiProvider client={api}>
+            <DocumentPage registration={registration} record={{ id: 'i1', number: 'A-42', total: 1500 }} onAction={onAction} currency='MXN' />
+        </ApiProvider>,
+    )
+    return { api, onAction }
+}
+
+describe('DocumentPage', () => {
+    it('muestra cabecera con dos badges de texto explícito y el total en la moneda de la org', async () => {
+        setup()
+        expect(screen.getByRole('heading', { name: 'A-42' })).toBeTruthy()
+        expect(screen.getByText('Timbrada')).toBeTruthy()
+        expect(screen.getByText('Parcial')).toBeTruthy()
+        expect(screen.getByText(/1,500\.00/)).toBeTruthy()
+    })
+
+    it('una primaria, secundarias visibles y la destructiva bloqueada con el contador de REP', async () => {
+        const { onAction } = setup()
+        await waitFor(() => expect(screen.getAllByText('1').length).toBeGreaterThan(0)) // contador del botón inteligente
+        fireEvent.click(screen.getByText('Registrar pago'))
+        await waitFor(() => expect(onAction).toHaveBeenCalledTimes(1))
+        expect(onAction.mock.calls[0][0].def.key).toBe('pay')
+        const cancel = screen.getByRole('button', { name: /Solicitar cancelación/ }) as HTMLButtonElement
+        expect(cancel.disabled).toBe(true)
+        fireEvent.click(cancel)
+        expect(onAction).toHaveBeenCalledTimes(1)
+    })
+
+    it('el botón inteligente abre la pestaña con las filas de la fuente', async () => {
+        setup()
+        await waitFor(() => expect(screen.getAllByText('1').length).toBeGreaterThan(0))
+        fireEvent.click(screen.getByRole('button', { name: /REP/ }))
+        await waitFor(() => expect(screen.getByText('REP-UUID-1')).toBeTruthy())
+    })
+
+    it('openUrl abre el archivo sin pasar por onAction', async () => {
+        const open = vi.spyOn(window, 'open').mockImplementation(() => null)
+        const { onAction } = setup()
+        fireEvent.click(screen.getByText('Descargar PDF'))
+        await waitFor(() => expect(open).toHaveBeenCalledWith('https://x/y.pdf', '_blank', 'noopener,noreferrer'))
+        expect(onAction).not.toHaveBeenCalled()
+    })
+})

package/src/document/__tests__/evaluate.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+import { evaluateWhen, interpolate, pruneUnavailableActions, readPath, resolveActions, resolveStatus, resolveTitle } from '../evaluate'
+import type { DocumentContext, DocumentSpec } from '../types'
+
+const ctx = (record: Record<string, unknown>, derived: Record<string, unknown> = {}, sources: DocumentContext['sources'] = {}): DocumentContext => ({
+    record,
+    derived,
+    sources,
+})
+
+const spec: DocumentSpec = {
+    model: 'docs',
+    title: '{{series}}{{number}} || {{id}}',
+    statuses: [
+        {
+            id: 'fiscal',
+            field: '$.fiscal',
+            states: [
+                { value: 'draft', label: 'Borrador', tone: 'neutral' },
+                { value: 'cancelled', label: 'Cancelada', tone: 'neutral', strike: true },
+            ],
+        },
+    ],
+    actions: [
+        { key: 'stamp', label: 'Timbrar factura' },
+        { key: 'preview', label: 'Vista previa' },
+        { key: 'edit', label: 'Editar' },
+        { key: 'a', label: 'A' },
+        { key: 'b', label: 'B' },
+        { key: 'dup', label: 'Duplicar' },
+        {
+            key: 'cancel',
+            label: 'Solicitar cancelación',
+            destructive: true,
+            blockedWhen: { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'Cancela primero los REP' },
+        },
+        { key: 'secret', label: 'Secreta', hiddenWhen: { field: 'locked', op: 'truthy' } },
+    ],
+    layouts: [
+        { when: { field: '$.fiscal', op: 'eq', value: 'draft' }, layout: { primary: 'stamp', secondary: ['preview', 'edit', 'a', 'b'], more: ['dup', 'secret'] } },
+        { when: [{ field: '$.fiscal', op: 'eq', value: 'stamped' }], layout: { primary: 'dup', destructive: ['cancel'] } },
+    ],
+    tabs: [],
+}
+
+describe('readPath', () => {
+    it('lee registro, derivados y totales de fuentes', () => {
+        const c = ctx({ a: { b: 1 } }, { x: 'y' }, { reps: [{}, {}] })
+        expect(readPath(c, 'a.b')).toBe(1)
+        expect(readPath(c, 'record.a.b')).toBe(1)
+        expect(readPath(c, '$.x')).toBe('y')
+        expect(readPath(c, 'sources.reps.length')).toBe(2)
+        expect(readPath(c, 'nope.deep')).toBeUndefined()
+    })
+})
+
+describe('evaluateWhen', () => {
+    it('AND de predicados y operadores', () => {
+        const c = ctx({ n: 5, s: 'a', e: '' })
+        expect(evaluateWhen(undefined, c)).toBe(true)
+        expect(evaluateWhen([{ field: 'n', op: 'gt', value: 3 }, { field: 's', op: 'in', value: ['a', 'b'] }], c)).toBe(true)
+        expect(evaluateWhen([{ field: 'n', op: 'gt', value: 3 }, { field: 's', op: 'neq', value: 'a' }], c)).toBe(false)
+        expect(evaluateWhen({ field: 'e', op: 'falsy' }, c)).toBe(true)
+        expect(evaluateWhen({ field: 's', op: 'not_in', value: ['z'] }, c)).toBe(true)
+    })
+})
+
+describe('resolveStatus', () => {
+    it('resuelve del catálogo, cae a neutral con el valor crudo y omite vacío', () => {
+        expect(resolveStatus(spec.statuses[0], ctx({}, { fiscal: 'cancelled' }))?.strike).toBe(true)
+        expect(resolveStatus(spec.statuses[0], ctx({}, { fiscal: 'raro' }))).toMatchObject({ label: 'raro', tone: 'neutral' })
+        expect(resolveStatus(spec.statuses[0], ctx({}, {}))).toBeUndefined()
+    })
+})
+
+describe('resolveActions', () => {
+    it('1 primaria, máx. 3 secundarias y el desborde va a «Más…»', () => {
+        const r = resolveActions(spec, ctx({}, { fiscal: 'draft' }))
+        expect(r.primary?.def.key).toBe('stamp')
+        expect(r.secondary.map((a) => a.def.key)).toEqual(['preview', 'edit', 'a'])
+        expect(r.more.map((a) => a.def.key)).toEqual(['b', 'dup', 'secret'])
+    })
+    it('hiddenWhen omite la acción', () => {
+        const r = resolveActions(spec, ctx({ locked: true }, { fiscal: 'draft' }))
+        expect(r.more.map((a) => a.def.key)).not.toContain('secret')
+    })
+    it('blockedWhen deja la destructiva visible pero bloqueada con motivo', () => {
+        const blocked = resolveActions(spec, ctx({}, { fiscal: 'stamped' }, { reps: [{ id: 1 }] }))
+        expect(blocked.destructive[0].blockedReason).toBe('Cancela primero los REP')
+        const free = resolveActions(spec, ctx({}, { fiscal: 'stamped' }, { reps: [] }))
+        expect(free.destructive[0].blockedReason).toBeUndefined()
+    })
+    it('blockedWhen admite varias reglas y muestra el motivo de la primera que aplica', () => {
+        const multi: DocumentSpec = {
+            ...spec,
+            actions: [
+                {
+                    key: 'cancel',
+                    label: 'Cancelar',
+                    destructive: true,
+                    blockedWhen: [
+                        { when: { field: 'sources.reps.length', op: 'gt', value: 0 }, reason: 'REP' },
+                        { when: { field: 'sources.notes.length', op: 'gt', value: 0 }, reason: 'NC' },
+                    ],
+                },
+            ],
+            layouts: [{ when: { field: '$.fiscal', op: 'eq', value: 'stamped' }, layout: { destructive: ['cancel'] } }],
+        }
+        expect(resolveActions(multi, ctx({}, { fiscal: 'stamped' }, { reps: [], notes: [{}] })).destructive[0].blockedReason).toBe('NC')
+        expect(resolveActions(multi, ctx({}, { fiscal: 'stamped' }, { reps: [{}], notes: [{}] })).destructive[0].blockedReason).toBe('REP')
+    })
+    it('sin regla que coincida no hay acciones', () => {
+        const r = resolveActions(spec, ctx({}, { fiscal: 'otro' }))
+        expect(r.primary).toBeUndefined()
+        expect(r.secondary).toEqual([])
+    })
+})
+
+describe('interpolate / resolveTitle', () => {
+    it('interpola y prueba alternativas', () => {
+        expect(interpolate('{{series}}-{{number}}', ctx({ series: 'A', number: 7 }))).toBe('A-7')
+        expect(resolveTitle(spec.title, ctx({ series: 'A', number: 7, id: 'x' }))).toBe('A7')
+        expect(resolveTitle(spec.title, ctx({ id: 'x' }))).toBe('x')
+    })
+})
+
+describe('pruneUnavailableActions', () => {
+    it('quita acciones sin acción de modelo, conserva href/openUrl/tab', () => {
+        const s: DocumentSpec = {
+            ...spec,
+            actions: [
+                { key: 'a', label: 'A' },
+                { key: 'b', label: 'B', modelAction: 'real' },
+                { key: 'c', label: 'C', tab: 'fiscal' },
+                { key: 'd', label: 'D', openUrl: '{{x}}' },
+            ],
+        }
+        expect(pruneUnavailableActions(s, ['real']).actions.map((a) => a.key)).toEqual(['b', 'c', 'd'])
+    })
+})

package/src/document/action-bar.tsx

@@ -0,0 +1,140 @@
+// ActionBar — barra de acciones de un documento (benchmark §5.4 / §6.2):
+// una primaria (verbo + sustantivo), 2–3 secundarias visibles, el resto en
+// «Más…» y las destructivas separadas (divisor) y en rojo. Una acción bloqueada se ve
+// deshabilitada con su motivo (no desaparece: el operador entiende por qué).
+import { useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Loader2, MoreHorizontal } from 'lucide-react'
+import {
+    Button,
+    DropdownMenu,
+    DropdownMenuContent,
+    DropdownMenuItem,
+    DropdownMenuTrigger,
+    Tooltip,
+    TooltipContent,
+    TooltipProvider,
+    TooltipTrigger,
+} from '@asteby/metacore-ui/primitives'
+import { cn } from '@asteby/metacore-ui/lib'
+import { DynamicIcon } from '../dynamic-icon'
+import type { ResolvedAction, ResolvedActionLayout } from './types'
+
+export interface ActionBarProps {
+    layout: ResolvedActionLayout
+    /**
+     * Ejecuta la acción. Si devuelve una promesa, el botón muestra `loading`
+     * hasta que se resuelve (acciones asíncronas, §6.2).
+     */
+    onAction: (action: ResolvedAction) => void | Promise<unknown>
+    className?: string
+}
+
+export function ActionBar({ layout, onAction, className }: ActionBarProps) {
+    const { t } = useTranslation()
+    const [busy, setBusy] = useState<string | null>(null)
+
+    const run = async (a: ResolvedAction) => {
+        if (a.blockedReason || busy) return
+        setBusy(a.def.key)
+        try {
+            await onAction(a)
+        } finally {
+            setBusy(null)
+        }
+    }
+
+    const label = (a: ResolvedAction) => t(a.def.label, { defaultValue: a.def.label })
+    const { primary, secondary, more, destructive } = layout
+    const hasMenu = more.length > 0
+
+    const button = (a: ResolvedAction, variant: 'default' | 'outline' | 'destructive') => {
+        const loading = busy === a.def.key
+        const btn = (
+            <Button
+                key={a.def.key}
+                type='button'
+                size='sm'
+                variant={variant === 'destructive' ? 'outline' : variant}
+                disabled={!!a.blockedReason || (!!busy && !loading)}
+                aria-disabled={!!a.blockedReason}
+                data-action={a.def.key}
+                onClick={() => run(a)}
+                className={cn(
+                    variant === 'destructive' &&
+                        'border-destructive/40 text-destructive hover:bg-destructive/10 hover:text-destructive',
+                )}
+            >
+                {loading ? (
+                    <Loader2 className='mr-1.5 h-4 w-4 animate-spin' />
+                ) : a.def.icon ? (
+                    <span className='mr-1.5 inline-flex h-4 w-4 items-center'>
+                        <DynamicIcon name={a.def.icon} className='h-4 w-4' />
+                    </span>
+                ) : null}
+                {label(a)}
+            </Button>
+        )
+        if (!a.blockedReason) return btn
+        return (
+            <Tooltip key={a.def.key}>
+                <TooltipTrigger asChild>
+                    {/* span: un botón disabled no dispara el tooltip */}
+                    <span tabIndex={0}>{btn}</span>
+                </TooltipTrigger>
+                <TooltipContent className='max-w-xs'>{t(a.blockedReason, { defaultValue: a.blockedReason })}</TooltipContent>
+            </Tooltip>
+        )
+    }
+
+    const item = (a: ResolvedAction) => (
+        <DropdownMenuItem
+            key={a.def.key}
+            disabled={!!a.blockedReason}
+            data-action={a.def.key}
+            onSelect={() => run(a)}
+        >
+            {a.def.icon ? (
+                <span className='mr-2 inline-flex h-4 w-4 items-center'>
+                    <DynamicIcon name={a.def.icon} className='h-4 w-4' />
+                </span>
+            ) : null}
+            <span className='flex flex-col'>
+                {label(a)}
+                {a.blockedReason ? (
+                    <span className='text-xs font-normal text-muted-foreground'>
+                        {t(a.blockedReason, { defaultValue: a.blockedReason })}
+                    </span>
+                ) : null}
+            </span>
+        </DropdownMenuItem>
+    )
+
+    return (
+        <TooltipProvider delayDuration={150}>
+            <div className={cn('flex flex-wrap items-center gap-2', className)} data-document-actions=''>
+                {primary ? button(primary, primary.def.destructive ? 'destructive' : 'default') : null}
+                {secondary.map((a) => button(a, 'outline'))}
+                {hasMenu ? (
+                    <DropdownMenu>
+                        <DropdownMenuTrigger asChild>
+                            <Button type='button' size='sm' variant='outline' aria-label={t('document.more', { defaultValue: 'Más…' })}>
+                                <MoreHorizontal className='mr-1.5 h-4 w-4' />
+                                {t('document.more', { defaultValue: 'Más…' })}
+                            </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align='end' className='min-w-56'>
+                            {more.map((a) => item(a))}
+                        </DropdownMenuContent>
+                    </DropdownMenu>
+                ) : null}
+                {destructive.length > 0 ? (
+                    <>
+                        <span aria-hidden className='mx-1 h-6 w-px bg-border' />
+                        {destructive.map((a) => button(a, 'destructive'))}
+                    </>
+                ) : null}
+            </div>
+        </TooltipProvider>
+    )
+}