@asteby/metacore-runtime-react 48.0.0 → 49.1.0

package/src/row-actions-menu.tsx

@@ -0,0 +1,159 @@
+// RowActionsMenu — el «…» de una fila: la acción primaria (si hay) arriba y
+// destacada, las principales debajo y las secundarias (compartir, imprimir,
+// correo, chat, PDF/XML y lo que aporten addons vía registerRecordAction)
+// agrupadas en un «Más…» discreto. Una acción por capacidad sin proveedor
+// activo, o una contribución cuyo addon no está instalado, no aparece.
+//
+// DynamicTable lo usa por defecto (getDynamicColumns) y los hosts que arman su
+// propia columna de acciones lo reutilizan en vez de duplicar el menú.
+import * as React from 'react'
+import { useTranslation } from 'react-i18next'
+import { MoreHorizontal } from 'lucide-react'
+// Root entry on purpose (not '/primitives'): see dropdown-menu-entry.test.ts.
+import {
+    Button,
+    DropdownMenu,
+    DropdownMenuContent,
+    DropdownMenuItem,
+    DropdownMenuSeparator,
+    DropdownMenuSub,
+    DropdownMenuSubContent,
+    DropdownMenuSubTrigger,
+    DropdownMenuTrigger,
+} from '@asteby/metacore-ui'
+import { DynamicIcon } from './dynamic-icon'
+import { translateMetadataLabel } from './dynamic-columns-helpers'
+import { RequiresAddonLock, resolveRequiresAddon, useRequiresAddonLabel } from './requires-addon'
+import { useInstalledAddons } from './installed-addons-context'
+import { isActionProviderActive, splitActionsByPriority, useRecordActions, type ResolvedRecordAction } from './record-actions'
+
+/**
+ * One entry of the row "…" menu. An action gated by a missing optional addon
+ * (`requiresAddon`) stays listed with a lock + tooltip; the click still goes to
+ * `onAction`, whose shared handler (useDynamicRowActions) opens the
+ * requires-addon dialog instead of executing.
+ */
+export function RowActionMenuItem({
+    action,
+    label,
+    onSelect,
+    className,
+}: {
+    action: any
+    label: React.ReactNode
+    onSelect: (e: React.MouseEvent) => void
+    className?: string
+}) {
+    const requirement = resolveRequiresAddon(action)
+    const requiresAddonLabel = useRequiresAddonLabel()
+    return (
+        <DropdownMenuItem
+            onClick={onSelect}
+            title={requirement ? requiresAddonLabel(requirement) : undefined}
+            data-requires-addon={requirement?.key}
+            data-action={action.key}
+            className={className}
+        >
+            <DynamicIcon name={action.icon || 'Zap'} className="mr-2 h-4 w-4" />
+            {label}
+            {requirement && <RequiresAddonLock requirement={requirement} />}
+        </DropdownMenuItem>
+    )
+}
+
+export interface RowActionsMenuProps {
+    /** Acciones de metadata ya filtradas por estado/condición de la fila. */
+    actions: any[]
+    row: Record<string, any>
+    /** Modelo de la fila: resuelve las acciones aportadas por addons. */
+    model?: string
+    onAction?: (actionKey: string, row: any) => void
+    /** Sustituye el ícono del disparador (p. ej. un spinner mientras imprime). */
+    triggerIcon?: React.ReactNode
+    disabled?: boolean
+}
+
+/**
+ * Modelo de las filas que pinta la tabla. DynamicTable lo provee: la factoría
+ * de columnas (getDynamicColumns) no recibe el modelo y el menú lo necesita
+ * para resolver las acciones aportadas por addons.
+ */
+export const RowActionsModelContext = React.createContext<string | undefined>(undefined)
+
+type MenuEntry =
+    | { kind: 'action'; action: any }
+    | { kind: 'contribution'; item: ResolvedRecordAction }
+
+export function RowActionsMenu({ actions, row, model, onAction, triggerIcon, disabled }: RowActionsMenuProps) {
+    const { t } = useTranslation()
+    const installed = useInstalledAddons()
+    const ctxModel = React.useContext(RowActionsModelContext)
+    const recordModel = model ?? ctxModel
+    const contributed = useRecordActions(recordModel ?? '', recordModel ? row : null).filter((c) => !!c.run)
+
+    const available = actions.filter((a) => isActionProviderActive(a, installed))
+    const { primary, main, secondary } = splitActionsByPriority(available)
+    const mainEntries: MenuEntry[] = main.map((action) => ({ kind: 'action', action }))
+    const secondaryEntries: MenuEntry[] = secondary.map((action) => ({ kind: 'action', action }))
+    for (const item of contributed) {
+        ;(item.priority === 'primary' ? mainEntries : secondaryEntries).push({ kind: 'contribution', item })
+    }
+
+    if (!primary && mainEntries.length === 0 && secondaryEntries.length === 0) return null
+
+    const renderEntry = (e: MenuEntry) =>
+        e.kind === 'action' ? (
+            <RowActionMenuItem
+                key={e.action.key}
+                action={e.action}
+                label={translateMetadataLabel(e.action.label, t)}
+                onSelect={() => onAction?.(e.action.key, row)}
+            />
+        ) : (
+            <DropdownMenuItem key={e.item.key} data-action={e.item.key} onClick={() => void e.item.run?.()}>
+                <DynamicIcon name={e.item.icon || 'Share2'} className="mr-2 h-4 w-4" />
+                {t(e.item.label, { defaultValue: e.item.label })}
+            </DropdownMenuItem>
+        )
+
+    const hasMain = !!primary || mainEntries.length > 0
+    const moreLabel = t('datatable.more_actions', { defaultValue: 'Más…' })
+
+    return (
+        <div className="flex items-center justify-end">
+            <DropdownMenu>
+                <DropdownMenuTrigger asChild>
+                    <Button variant="ghost" className="h-8 w-8 p-0" disabled={disabled} onClick={(e: React.MouseEvent) => e.stopPropagation()}>
+                        <span className="sr-only">{t('datatable.open_menu', { defaultValue: 'Abrir menú' })}</span>
+                        {triggerIcon ?? <MoreHorizontal className="h-4 w-4" />}
+                    </Button>
+                </DropdownMenuTrigger>
+                <DropdownMenuContent align="end" onClick={(e: React.MouseEvent) => e.stopPropagation()}>
+                    {primary ? (
+                        <RowActionMenuItem
+                            action={primary}
+                            label={translateMetadataLabel(primary.label, t)}
+                            onSelect={() => onAction?.(primary.key, row)}
+                            className="font-semibold"
+                        />
+                    ) : null}
+                    {mainEntries.map(renderEntry)}
+                    {secondaryEntries.length > 0 && hasMain ? (
+                        <>
+                            <DropdownMenuSeparator />
+                            <DropdownMenuSub>
+                                <DropdownMenuSubTrigger data-row-more="" className="text-muted-foreground">
+                                    {moreLabel}
+                                </DropdownMenuSubTrigger>
+                                <DropdownMenuSubContent data-row-secondary="">{secondaryEntries.map(renderEntry)}</DropdownMenuSubContent>
+                            </DropdownMenuSub>
+                        </>
+                    ) : (
+                        // Sin principales no hay con qué competir: lista plana.
+                        secondaryEntries.map(renderEntry)
+                    )}
+                </DropdownMenuContent>
+            </DropdownMenu>
+        </div>
+    )
+}

package/src/slot.tsx

@@ -1,56 +1,19 @@
-// Slot / SlotRegistry — named extension points the host renders and addons
-// contribute to at register() time. Keyed by a slot id (e.g. "dashboard.widgets",
+// Slot — named extension points the host renders and addons contribute to at
+// register() time. Keyed by a slot id (e.g. "dashboard.widgets",
 // "invoice.footer"). Each contribution is an arbitrary React element factory.
+//
+// El store es `slotStore` de @asteby/metacore-sdk: el mismo donde escribe
+// `api.registry.registerSlot` (AddonAPI) y `registerDocumentContribution`, así
+// que hay una sola lista por slot. Una entrada con addon dueño (`owner`) que
+// consta como NO instalado (InstalledAddonsProvider) no se pinta.
 import React, { useSyncExternalStore } from 'react'
+import { slotStore, type SlotComponent, type SlotEntry } from '@asteby/metacore-sdk'
+import { useInstalledAddons } from './installed-addons-context'
 
-export type SlotComponent<P = any> = React.ComponentType<P>
+export type { SlotComponent, SlotEntry }
 
-interface SlotEntry {
-    id: string
-    component: SlotComponent
-    priority: number
-    source?: string
-}
-
-type Listener = () => void
-
-class SlotRegistryImpl {
-    private slots = new Map<string, SlotEntry[]>()
-    private listeners = new Set<Listener>()
-
-    register(slotId: string, component: SlotComponent, opts?: { priority?: number; source?: string }): () => void {
-        const entry: SlotEntry = { id: slotId, component, priority: opts?.priority ?? 0, source: opts?.source }
-        const list = this.slots.get(slotId) ?? []
-        list.push(entry)
-        // Higher priority renders first — canonical across SDK and runtime-react.
-        // See docs/slot-priority.md.
-        list.sort((a, b) => b.priority - a.priority)
-        this.slots.set(slotId, list)
-        this.emit()
-        return () => {
-            const arr = this.slots.get(slotId)
-            if (!arr) return
-            const idx = arr.indexOf(entry)
-            if (idx >= 0) {
-                arr.splice(idx, 1)
-                this.emit()
-            }
-        }
-    }
-
-    get(slotId: string): SlotEntry[] {
-        return this.slots.get(slotId) ?? []
-    }
-
-    subscribe(listener: Listener): () => void {
-        this.listeners.add(listener)
-        return () => { this.listeners.delete(listener) }
-    }
-
-    private emit() { this.listeners.forEach(l => l()) }
-}
-
-export const slotRegistry = new SlotRegistryImpl()
+/** Alias histórico del store canónico (`slotRegistry.register/get/subscribe`). */
+export const slotRegistry = slotStore
 
 export interface SlotProps {
     /** Slot id. */
@@ -62,11 +25,13 @@ export interface SlotProps {
 }
 
 export function Slot({ name, props, fallback = null }: SlotProps) {
-    const entries = useSyncExternalStore(
-        (cb) => slotRegistry.subscribe(cb),
-        () => slotRegistry.get(name),
-        () => slotRegistry.get(name),
+    const all = useSyncExternalStore(
+        (cb) => slotStore.subscribe(cb),
+        () => slotStore.get(name),
+        () => slotStore.get(name),
     )
+    const installed = useInstalledAddons()
+    const entries = installed ? all.filter((e) => !e.owner || installed.addons.has(e.owner)) : all
     if (entries.length === 0) return <>{fallback}</>
     return (
         <>

package/src/types.ts

@@ -107,6 +107,13 @@ export interface DocumentFormType {
      * reparte el pago en PaymentAllocation dentro de una transacción.
      */
     submit_action?: string
+    /**
+     * El alta de este tipo vive en OTRO modelo (`customers.Invoice`): «Crear»
+     * no pinta formulario, el host abre la página de ese modelo con su alta
+     * abierta (`onDelegateCreate`). P. ej. Documentos fiscales → Facturas: la
+     * factura nace en customers y se timbra después. Sin campos ni renglones.
+     */
+    create_model?: string
 }
 
 /** Contraparte: qué campo del encabezado la elige y qué muestra su tarjeta. */
@@ -141,6 +148,20 @@ export interface DocumentFormSource {
     option_filter?: unknown
     /** Addon requerido (gating de UI; el servidor revalida). */
     requires_addon?: string
+    /** Columna de cantidad del renglón origen (default `quantity`). */
+    qty_field?: string
+    /**
+     * Columna del renglón de ESTE documento que guarda el id del renglón origen
+     * (p. ej. `sales_order_item_id`). Con ella el host sirve lo pendiente por
+     * renglón (`<endpoint>/source-lines`) y rechaza al guardar si se excede.
+     */
+    line_link_field?: string
+    /** Columna del renglón origen que ya trae lo pendiente (la mantiene su addon). */
+    remaining_qty_field?: string
+    /** Endpoint del addon que sirve los renglones con `remaining_quantity` (`?id=`). */
+    remaining_endpoint?: string
+    /** Estados de este documento que no consumen el origen (cancelada…). */
+    exclude_states?: string[]
 }
 
 /** Vista previa: acción de fila sobre el borrador, llamada con `analyze: true`. */
@@ -907,6 +928,18 @@ export interface ActionDefinition {
      */
     replaces_create?: boolean
     replacesCreate?: boolean
+    /**
+     * Manifest v3 `priority`. "primary": la única acción destacada del menú de
+     * fila / cabecera. "secondary": compartir, imprimir, correo, chat → pie del
+     * documento y «Más…» del menú de fila. Sin valor: convención por clave
+     * (ver classifyActionPriority).
+     */
+    priority?: 'primary' | 'secondary'
+    /**
+     * Cómo despacha (served `trigger`). `type: "capability"` necesita un addon
+     * que provea `capability`; sin proveedor activo la acción no se ofrece.
+     */
+    trigger?: { type: string; capability?: string; connector?: string }
     /**
      * Optional addon this action depends on, stamped by the host only while it
      * is NOT installed (served as `requires_addon`; read through
@@ -958,6 +991,8 @@ export interface ActionMetadata {
     /** Federated modal slug "<addon_key>.<action_key>"; see ActionModalDispatcher. */
     modal?: string
     placement?: 'row' | 'table' | 'create'
+    /** Manifest v3 `priority`; ver ActionDefinition.priority. */
+    priority?: 'primary' | 'secondary'
     /**
      * Optional addon this action depends on, stamped by the host only while it
      * is NOT installed (served as `requires_addon`; read through