@asteby/metacore-runtime-react 47.1.0 → 49.0.0

package/src/business/document-lines.ts

@@ -31,17 +31,21 @@ export function applyProductToLine(
     const list = variant?.price ?? product.price
     const cost = variant?.cost ?? product.cost
     const catalog = source === 'cost' ? (cost ?? list) : list
+    // Nunca cantidad 0: un renglón vacío (o con la celda borrada) entra con 1.
+    const qty = opts.quantity ?? toAmount(line.quantity)
     return {
         ...line,
         kind: 'item',
         product_id: variant?.id ?? product.id,
         sku: variant?.sku ?? product.sku,
         description: variant ? `${product.name} · ${variant.label}` : product.name,
-        quantity: opts.quantity ?? (toAmount(line.quantity) || 1),
+        quantity: qty !== 0 ? qty : 1,
         unit_price: priceFromProduct(product, variant, source),
         catalog_price: catalog,
         cost,
         tax_rate: product.tax_rate ?? line.tax_rate ?? 0,
+        unit: product.unit ?? line.unit,
+        extensions: product.extensions ? { ...(line.extensions ?? {}), ...product.extensions } : line.extensions,
         available: availableStock(src, opts.warehouseId) ?? availableStock(product, opts.warehouseId),
     }
 }

package/src/business/index.ts

@@ -19,3 +19,8 @@ export * from './inspection-checklist'
 export * from './vehicle-picker'
 export * from './relate-documents'
 export * from './print-send-dialog'
+export * from './catalog-product-search'
+export * from './document-editor-model'
+export * from './document-editor-panels'
+export * from './payment-allocator'
+export * from './document-editor'

package/src/business/line-items.ts

@@ -32,11 +32,24 @@ export interface LineItem {
     cost?: number
     /** Tope de cantidad (NC: facturado − acreditado; devolución: vendido − devuelto). */
     max_quantity?: number
+    /**
+     * Id del renglón del documento origen («crear desde»). Viaja en la columna
+     * `line_link_field` de la fuente para que el servidor descuente y valide lo
+     * pendiente; un renglón libre no lo lleva.
+     */
+    source_line_id?: string
     technician_id?: string
     lot?: string
     dot?: string
     /** Existencia disponible conocida (para la política de sobreventa). */
     available?: number
+    /**
+     * Campos de extensión del renglón que aportan OTROS addons (p. ej.
+     * fiscal_mexico: `mx_clave_prod_serv`, `mx_clave_unidad`), copiados del
+     * producto al elegirlo. Viajan en `fiscal_data` (la bolsa de ModelExtension
+     * del host) — el SDK no conoce sus claves.
+     */
+    extensions?: Record<string, string>
 }
 
 /** Qué hacer si `quantity > available`. */
@@ -196,7 +209,10 @@ export function validateLineItems(lines: LineItem[], policy: LineItemsPolicy = {
  * Forma que se manda al backend: números reales (nunca `""`), sin claves de UI,
  * opcionales vacíos omitidos y `position` 1-based conservando el orden.
  */
-export function serializeLineItems(lines: LineItem[]): Array<Record<string, unknown>> {
+export function serializeLineItems(
+    lines: LineItem[],
+    opts: { /** Columna que recibe `source_line_id` (la `line_link_field` de la fuente). */ sourceLineField?: string } = {},
+): Array<Record<string, unknown>> {
     return lines.map((l, i) => {
         const out: Record<string, unknown> = {
             position: i + 1,
@@ -214,6 +230,13 @@ export function serializeLineItems(lines: LineItem[]): Array<Record<string, unkn
                 const v = l[k]
                 if (typeof v === 'string' && v.trim()) out[k] = v.trim()
             }
+            if (l.extensions && Object.keys(l.extensions).length > 0) out.fiscal_data = { ...l.extensions }
+            if (opts.sourceLineField && l.source_line_id) out[opts.sourceLineField] = l.source_line_id
+            // Importes ya calculados: un modelo de renglón sin tasa (solo
+            // `tax_amount`/`subtotal`) los guarda tal cual en vez de perder el IVA.
+            const a = computeLine(l)
+            out.subtotal = a.net
+            out.tax_amount = a.tax
         }
         return out
     })
@@ -231,7 +254,7 @@ export function parseLineItems(rows: unknown): LineItem[] {
             product_id: str(o.product_id),
             sku: str(o.sku),
             description: typeof o.description === 'string' ? o.description : '',
-            quantity: o.quantity == null ? 1 : toAmount(o.quantity),
+            quantity: o.quantity == null || o.quantity === '' ? 1 : toAmount(o.quantity),
             unit_price: toAmount(o.unit_price),
             discount: toAmount(o.discount),
             discount_kind: o.discount_kind === 'amount' ? 'amount' : undefined,
@@ -243,6 +266,12 @@ export function parseLineItems(rows: unknown): LineItem[] {
             technician_id: str(o.technician_id),
             lot: str(o.lot),
             dot: str(o.dot),
+            extensions:
+                o.fiscal_data && typeof o.fiscal_data === 'object'
+                    ? (Object.fromEntries(
+                          Object.entries(o.fiscal_data as Record<string, unknown>).filter(([, v]) => typeof v === 'string'),
+                      ) as Record<string, string>)
+                    : undefined,
         })
     })
 }

package/src/business/payment-allocator.tsx

@@ -0,0 +1,110 @@
+// PaymentAllocator — UI del reparto de un pago entre los documentos abiertos de
+// la contraparte (cobro multi-factura / REP, CxP «Aplicar pago»). Las reglas
+// son las de primitives/allocation (allocatePayment / validateAllocation); aquí
+// solo se pintan y se editan. Por defecto reparte solo, del más vencido al más
+// reciente; al teclear un monto pasa a manual sin perder lo ya repartido.
+import { useTranslation } from 'react-i18next'
+import { Badge, Button } from '@asteby/metacore-ui/primitives'
+import { Input } from '@asteby/metacore-ui'
+import type { AllocationResult, AllocationStrategy, OpenDocument } from '../primitives/allocation'
+import { manualFromAllocations, overdueDays } from './document-editor-model'
+import { useFormatter } from './format'
+
+export interface PaymentAllocatorValue {
+    strategy: AllocationStrategy
+    manual: Record<string, number>
+}
+
+export interface PaymentAllocatorProps {
+    documents: OpenDocument[]
+    /** Resultado de `allocatePayment(amount, documents, value.strategy, value.manual)`. */
+    result: AllocationResult
+    value: PaymentAllocatorValue
+    onChange: (next: PaymentAllocatorValue) => void
+    currency?: string
+    loading?: boolean
+    readOnly?: boolean
+    /** Hoy (para los días de atraso; inyectable en tests). */
+    today?: Date
+}
+
+const num = (s: string): number => (s.trim() === '' ? 0 : Number(s.replace(',', '.')) || 0)
+
+export function PaymentAllocator({ documents, result, value, onChange, currency, loading, readOnly, today }: PaymentAllocatorProps) {
+    const { t } = useTranslation()
+    const fmt = useFormatter({ currency })
+    const byDoc = new Map(result.allocations.map((a) => [a.document_id, a]))
+
+    if (loading) {
+        return <p className="text-sm text-muted-foreground">{t('paymentAllocator.loading', { defaultValue: 'Buscando documentos con saldo…' })}</p>
+    }
+    if (documents.length === 0) {
+        return (
+            <p className="text-sm text-muted-foreground" data-slot="payment-allocator-empty">
+                {t('paymentAllocator.empty', { defaultValue: 'No hay documentos con saldo pendiente.' })}
+            </p>
+        )
+    }
+
+    const setAmount = (id: string, amount: number) =>
+        onChange({ strategy: 'manual', manual: { ...manualFromAllocations(result.allocations), [id]: amount } })
+
+    return (
+        <div className="space-y-2" data-slot="payment-allocator">
+            <div className="flex items-center justify-between gap-3 text-xs text-muted-foreground">
+                <span>
+                    {value.strategy === 'manual'
+                        ? t('paymentAllocator.manual', { defaultValue: 'Reparto manual' })
+                        : t('paymentAllocator.auto', { defaultValue: 'Se aplica primero a lo más vencido' })}
+                </span>
+                {!readOnly && value.strategy === 'manual' && (
+                    <Button type="button" variant="ghost" size="sm" onClick={() => onChange({ strategy: 'oldest_due_first', manual: {} })}>
+                        {t('paymentAllocator.autoapply', { defaultValue: 'Autoaplicar' })}
+                    </Button>
+                )}
+            </div>
+            <ul className="divide-y rounded-md border">
+                {documents.map((d) => {
+                    const a = byDoc.get(d.id)
+                    const late = overdueDays(d, today)
+                    return (
+                        <li key={d.id} className="flex flex-wrap items-center gap-3 px-3 py-2 text-sm" data-document={d.id}>
+                            <div className="min-w-0 flex-1">
+                                <div className="flex items-center gap-2">
+                                    <span className="font-medium">{d.number}</span>
+                                    {late > 0 && (
+                                        <Badge variant="secondary">{t('paymentAllocator.overdue', { defaultValue: 'Vencida · {{days}} d', days: late })}</Badge>
+                                    )}
+                                    {d.payment_method && <span className="text-xs text-muted-foreground">{d.payment_method}</span>}
+                                </div>
+                                <div className="text-xs text-muted-foreground">
+                                    {t('paymentAllocator.balance', { defaultValue: 'Saldo' })} {fmt.money(d.balance, d.currency)}
+                                    {a && a.balance_after > 0 && (
+                                        <>
+                                            {' · '}
+                                            {t('paymentAllocator.installment', { defaultValue: 'Parcialidad {{n}}', n: a.installment })}
+                                            {' · '}
+                                            {t('paymentAllocator.remaining', { defaultValue: 'Queda' })} {fmt.money(a.balance_after, d.currency)}
+                                        </>
+                                    )}
+                                </div>
+                            </div>
+                            <Input
+                                type="number"
+                                inputMode="decimal"
+                                min={0}
+                                step="0.01"
+                                aria-label={t('paymentAllocator.apply_to', { defaultValue: 'Aplicar a {{number}}', number: d.number })}
+                                className="h-9 w-32 text-right tabular-nums"
+                                value={a ? String(a.amount) : ''}
+                                placeholder="0.00"
+                                disabled={readOnly}
+                                onChange={(e) => setAmount(d.id, num(e.target.value))}
+                            />
+                        </li>
+                    )
+                })}
+            </ul>
+        </div>
+    )
+}

package/src/business/product-search.ts

@@ -80,6 +80,10 @@ export interface ProductResult {
     stock?: StockByWarehouse[]
     /** Paquetes automáticos: ids/nombres que se sugieren junto al producto. */
     bundle_items?: Array<{ product_id: string; name: string; quantity: number }>
+    /** Unidad de venta del catálogo (pza, juego, kg…). */
+    unit?: string
+    /** Campos de extensión del producto (fiscal_data.*) que se copian al renglón. */
+    extensions?: Record<string, string>
 }
 
 /** Existencia disponible: de la variante o del producto, en un almacén o en total. */

package/src/dialogs/dynamic-record.tsx

@@ -10,7 +10,7 @@
 // the image-url resolver and the org IANA timezone — are passed as props so the
 // SDK stays transport- and host-agnostic.
 import { emitRecordMutation } from '../record-mutation-events'
-import { createContext, useCallback, useContext, useEffect, useId, useRef, useState } from 'react'
+import { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import type { ModelSchema } from './types'
 
@@ -69,13 +69,14 @@ import type { VisibleWhen } from '../types'
 import { groupFieldsBySection, type FormLayout } from '../form-layout'
 import { FieldSection, WizardProgress } from '../form-layout-ui'
 import { AssistInterview } from '../assist-interview'
+import { RecordPrefillBar } from '../record-prefill-bar'
 import { FieldCell } from '../field-grid'
 import { isNilUuid, normalizeNilUuid } from '../nil-uuid'
 import { normalizeRefFieldsForSubmit } from './normalize-submit'
 import { validateValues, bagHasErrors, exemptUnchangedRuleIssues } from '../validator'
 import { DynamicIcon, isLucideIconName } from '../dynamic-icon'
 import { IconPickerField } from '../icon-picker-field'
-import { humanizeToken } from '../dynamic-columns-helpers'
+import { humanizeToken, localizeFieldLabel } from '../dynamic-columns-helpers'
 import { formatDateCell } from '../dynamic-columns'
 import {
     ImageStack,
@@ -667,6 +668,17 @@ export function DynamicRecordDialog({
     const isCreate = mode === 'create'
     const isView = mode === 'view'
     const isEditable = mode === 'create' || mode === 'edit'
+    // Claves que un ayudante de captura (RecordPrefillBar) puede escribir: sólo
+    // los campos que este formulario declara (incluye fiscal_data.* de las
+    // ModelExtension). Readonly fuera: un prefill no salta un candado.
+    const prefillAllowedKeys = useMemo(
+        () => new Set<string>((modalMeta?.fields ?? []).filter((f: any) => !f.readonly).map((f: any) => f.key)),
+        [modalMeta],
+    )
+    const applyPrefill = useCallback(
+        (patch: Record<string, any>) => setFormValues(prev => ({ ...prev, ...patch })),
+        [],
+    )
     const config = MODE_CONFIG[mode]
 
     // ── Fetch metadata + record when dialog opens ──────────────────────────
@@ -851,7 +863,7 @@ export function DynamicRecordDialog({
     // with no matching form field).
     const labelForKey = (key: string): string => {
         const f = (modalMeta?.fields ?? []).find(x => x.key === key)
-        if (f?.label) return f.label
+        if (f?.label) return localizeFieldLabel(f.label, t)
         return key.replace(/[._-]+/g, ' ').replace(/\b\w/g, c => c.toUpperCase())
     }
 
@@ -903,7 +915,7 @@ export function DynamicRecordDialog({
             }
             if (bagHasErrors(bag)) {
                 const labels: Record<string, string> = {}
-                for (const f of visible) labels[f.key] = f.label
+                for (const f of visible) labels[f.key] = localizeFieldLabel(f.label, t)
                 const next = localizeFieldErrorMap(bag, t, { labels })
                 setFieldErrors(next)
                 const description = Object.entries(next)
@@ -1077,7 +1089,7 @@ export function DynamicRecordDialog({
         const bag = validateValues(stepFields as ActionFieldDef[], formValues)
         if (bagHasErrors(bag)) {
             const labels: Record<string, string> = {}
-            for (const f of stepFields) labels[f.key] = f.label
+            for (const f of stepFields) labels[f.key] = localizeFieldLabel(f.label, t)
             setFieldErrors(localizeFieldErrorMap(bag, t, { labels }))
             toast.error(t('dynamic.validation_failed', { defaultValue: 'Revisa los campos marcados' }))
             return
@@ -1111,6 +1123,16 @@ export function DynamicRecordDialog({
                                 two-column grid, unchanged. FieldCell gives each
                                 cell `min-w-0` so a long select/input value can't
                                 blow the two columns past the dialog width. */}
+                            {isEditable && (
+                                <RecordPrefillBar
+                                    model={model}
+                                    mode={isCreate ? 'create' : 'edit'}
+                                    recordId={recordId}
+                                    values={formValues}
+                                    allowedKeys={prefillAllowedKeys}
+                                    onApply={applyPrefill}
+                                />
+                            )}
                             <form
                                 id={formId}
                                 // Stable Aby / guidance contract: unique id={formId}
@@ -1313,11 +1335,12 @@ function FieldRow({ field, record, value, mode, onChange, error, locked }: Field
     // the rich read-only renderer. `locked` forces the same disabled rendering on
     // CREATE for a caller-specified field (see `lockedFields`).
     const isEditReadonly = (mode === 'edit' && !!field.readonly) || !!locked
+    const { t } = useTranslation()
 
     return (
         <div className="flex flex-col gap-1.5" data-aby-field={field.key}>
             <Label className="text-xs font-medium text-muted-foreground uppercase tracking-wide">
-                {field.label}
+                {localizeFieldLabel(field.label, t)}
                 {field.required && mode !== 'view' && !isEditReadonly && (
                     <span className="text-destructive ml-0.5">*</span>
                 )}

package/src/document/document-page.tsx

@@ -8,6 +8,7 @@ import { useTranslation } from 'react-i18next'
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@asteby/metacore-ui/primitives'
 import { cn } from '@asteby/metacore-ui/lib'
 import { ActionBar } from './action-bar'
+import { DocumentSecondaryBar } from './secondary-bar'
 import { DocumentHeader, type HeaderBadge, type HeaderMetric } from './document-header'
 import { SmartButtons, type SmartButtonItem } from './smart-buttons'
 import { StatusBadge } from './status-badge'
@@ -175,6 +176,20 @@ export function DocumentPage(props: DocumentPageProps) {
                     </TabsContent>
                 ))}
             </Tabs>
+
+            {/* Compartir / imprimir / correo / PDF-XML y lo que aporten los
+                addons instalados: al pie, no compitiendo con la primaria. */}
+            <DocumentSecondaryBar
+                items={layout.footer.map((a) => ({
+                    key: a.def.key,
+                    label: a.def.label,
+                    icon: a.def.icon,
+                    blockedReason: a.blockedReason,
+                    run: () => handleAction(a),
+                }))}
+                model={spec.model}
+                record={record}
+            />
         </div>
     )
 }

package/src/document/evaluate.ts

@@ -1,3 +1,4 @@
+import { classifyActionPriority } from '../action-priority'
 import type {
     ActionLayout,
     DocumentActionDef,
@@ -130,12 +131,15 @@ export function resolveActions(spec: DocumentSpec, ctx: DocumentContext): Resolv
     const destructive = many(layout.destructive)
     const secondary: ResolvedAction[] = []
     const more: ResolvedAction[] = []
+    const footer: ResolvedAction[] = []
     for (const a of [...many(layout.secondary)]) {
         if (a.def.destructive) destructive.push(a)
+        else if (isFooterAction(a.def)) footer.push(a)
         else secondary.push(a)
     }
     for (const a of many(layout.more)) {
         if (a.def.destructive) destructive.push(a)
+        else if (isFooterAction(a.def)) footer.push(a)
         else more.push(a)
     }
     const overflow = secondary.splice(MAX_VISIBLE_SECONDARY)
@@ -146,7 +150,19 @@ export function resolveActions(spec: DocumentSpec, ctx: DocumentContext): Resolv
         destructive.unshift(primary)
         primary = undefined
     }
-    return { primary, secondary, more, destructive }
+    return { primary, secondary, more, destructive, footer }
+}
+
+/**
+ * ¿Va al pie? `priority: secondary`, o la convención por clave sobre la acción
+ * del modelo (`modelAction ?? key`): compartir, imprimir, correo, chat, PDF/XML.
+ */
+function isFooterAction(def: DocumentActionDef): boolean {
+    if (def.priority) return def.priority === 'secondary'
+    return (
+        classifyActionPriority({ key: def.key }) === 'secondary' ||
+        (!!def.modelAction && classifyActionPriority({ key: def.modelAction }) === 'secondary')
+    )
 }
 
 /** Interpola `{{campo}}` con valores del registro (sin evaluar código). */

package/src/document/index.ts

@@ -13,6 +13,7 @@ export {
 export { formatFieldValue, type FieldFormatOptions } from './format'
 export { StatusBadge, STATUS_TONE_STYLE, type StatusBadgeProps } from './status-badge'
 export { ActionBar, type ActionBarProps } from './action-bar'
+export { DocumentSecondaryBar, type DocumentSecondaryBarProps, type SecondaryBarItem } from './secondary-bar'
 export { DocumentHeader, type DocumentHeaderProps, type HeaderBadge, type HeaderMetric } from './document-header'
 export { SmartButtons, type SmartButtonItem, type SmartButtonsProps } from './smart-buttons'
 export { DocumentTimeline, type DocumentTimelineProps, type TimelineEntry } from './document-timeline'

package/src/document/secondary-bar.tsx

@@ -0,0 +1,92 @@
+// DocumentSecondaryBar — pie del documento con las acciones secundarias:
+// compartir, imprimir/descargar PDF o XML, enviar por correo, enviar al chat…
+// La cabecera se queda con UNA primaria (y sus principales); esto va abajo,
+// discreto. Junta dos fuentes:
+//   - `items`: acciones del propio documento/modelo ya clasificadas como
+//     secundarias (resolveActions → `footer`, o splitActionsByPriority);
+//   - las aportadas por addons/host con registerRecordAction, sólo si su
+//     proveedor está instalado y activo (useRecordActions).
+// Sin nada que mostrar no pinta nada.
+import { useState, type ReactNode } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Loader2 } from 'lucide-react'
+import { Button } from '@asteby/metacore-ui/primitives'
+import { cn } from '@asteby/metacore-ui/lib'
+import { DynamicIcon } from '../dynamic-icon'
+import { useRecordActions } from '../record-actions'
+
+export interface SecondaryBarItem {
+    key: string
+    label: string
+    icon?: string
+    /** Deshabilitada con su motivo (no desaparece). */
+    blockedReason?: string
+    run: () => unknown
+}
+
+export interface DocumentSecondaryBarProps {
+    items?: SecondaryBarItem[]
+    /** Modelo + registro: resuelven las acciones aportadas por addons. */
+    model?: string
+    record?: Record<string, unknown> | null
+    /** Controles extra del host (al final). */
+    children?: ReactNode
+    className?: string
+}
+
+export function DocumentSecondaryBar({ items = [], model, record, children, className }: DocumentSecondaryBarProps) {
+    const { t } = useTranslation()
+    const contributed = useRecordActions(model ?? '', model ? record : null)
+    const [busy, setBusy] = useState<string | null>(null)
+
+    const run = async (key: string, fn?: () => unknown) => {
+        if (!fn || busy) return
+        setBusy(key)
+        try {
+            await fn()
+        } finally {
+            setBusy(null)
+        }
+    }
+
+    const all: SecondaryBarItem[] = [
+        ...items,
+        ...contributed.filter((c) => c.run).map((c) => ({ key: c.key, label: c.label, icon: c.icon, run: c.run! })),
+    ]
+    const rendered = contributed.filter((c) => c.render && !c.run)
+    if (all.length === 0 && rendered.length === 0 && !children) return null
+
+    return (
+        <footer
+            className={cn('flex flex-wrap items-center gap-1.5 border-t pt-3', className)}
+            data-document-secondary=''
+            aria-label={t('datatable.secondary_actions', { defaultValue: 'Compartir y documentos' })}
+        >
+            {all.map((a) => (
+                <Button
+                    key={a.key}
+                    type='button'
+                    size='sm'
+                    variant='ghost'
+                    className='text-muted-foreground'
+                    data-action={a.key}
+                    disabled={!!a.blockedReason || (!!busy && busy !== a.key)}
+                    title={a.blockedReason ? t(a.blockedReason, { defaultValue: a.blockedReason }) : undefined}
+                    onClick={() => void run(a.key, a.run)}
+                >
+                    {busy === a.key ? (
+                        <Loader2 className='mr-1.5 h-4 w-4 animate-spin' />
+                    ) : a.icon ? (
+                        <DynamicIcon name={a.icon} className='mr-1.5 h-4 w-4' />
+                    ) : null}
+                    {t(a.label, { defaultValue: a.label })}
+                </Button>
+            ))}
+            {rendered.map((c) => {
+                const C = c.render!
+                return <C key={c.key} model={model!} record={record!} />
+            })}
+            {children}
+        </footer>
+    )
+}

package/src/document/types.ts

@@ -64,6 +64,12 @@ export interface DocumentActionDef {
     href?: string
     openUrl?: string
     tab?: string
+    /**
+     * "secondary" (o, sin valor, una clave de compartir/imprimir/correo/chat/
+     * PDF/XML por convención) saca la acción de la cabecera y la pone en la
+     * barra secundaria del pie — salvo que el layout la haga primaria.
+     */
+    priority?: 'primary' | 'secondary'
     /** Estilo crítico: siempre va en la zona destructiva. */
     destructive?: boolean
     /** Se muestra deshabilitada con el motivo en lugar de desaparecer. */
@@ -200,6 +206,8 @@ export interface ResolvedActionLayout {
     secondary: ResolvedAction[]
     more: ResolvedAction[]
     destructive: ResolvedAction[]
+    /** Secundarias (compartir, imprimir, correo…) → DocumentSecondaryBar, no la cabecera. */
+    footer: ResolvedAction[]
 }
 
 export type DocumentSlotRenderer = (ctx: DocumentContext) => ReactNode