@asteby/metacore-runtime-react 47.0.0 → 48.0.0

package/src/__tests__/document-editor-model.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest'
+import {
+    allocationAmountField,
+    allocationIssueMessages,
+    allocationPayload,
+    creditStatus,
+    editorLinesConfig,
+    friendlyOptionLabel,
+    isEditorLayout,
+    linesFromSource,
+    localIssues,
+    overdueDays,
+    partyDefaults,
+    partySummaryRows,
+    splitEditorFields,
+    toOpenDocuments,
+} from '../business/document-editor-model'
+import { makeLine } from '../business/line-items'
+import { allocatePayment, validateAllocation } from '../primitives/allocation'
+import type { ActionFieldDef, DocumentFormOpenDocuments } from '../types'
+
+describe('divulgación progresiva (splitEditorFields)', () => {
+    const fields: ActionFieldDef[] = [
+        { key: 'customer_id', label: 'Cliente', type: 'dynamic_select', required: true },
+        { key: 'payment_form', label: 'Forma de pago', type: 'select', required: true, options: [{ value: '03', label: '03 · Transferencia' }] },
+        { key: 'method', label: 'Método', type: 'select', defaultValue: 'PUE', options: [{ value: 'PUE', label: 'PUE · Una exhibición' }] },
+        { key: 'series', label: 'Serie', type: 'text', section: 'fiscal' },
+        { key: 'notes', label: 'Notas', type: 'textarea' },
+    ]
+    const ext: ActionFieldDef[] = [{ key: 'fiscal_data.uso_cfdi', label: 'Uso CFDI', type: 'select' }]
+
+    it('a la vista: contraparte y lo obligatorio; plegado: extensiones, section fiscal y catálogos con default', () => {
+        const g = splitEditorFields(fields, { partyField: 'customer_id', extensionFields: ext })
+        expect(g.party?.key).toBe('customer_id')
+        expect(g.essential.map((f) => f.key)).toEqual(['payment_form'])
+        expect(g.advanced.map((f) => f.key)).toEqual(['method', 'series', 'fiscal_data.uso_cfdi'])
+        expect(g.notes.map((f) => f.key)).toEqual(['notes'])
+    })
+
+    it('essentialKeys gana (monto del cobro, campo de vínculo del origen)', () => {
+        const g = splitEditorFields(fields, { essentialKeys: ['method'] })
+        expect(g.essential.map((f) => f.key)).toContain('method')
+    })
+
+    it('el código SAT queda como dato secundario', () => {
+        expect(friendlyOptionLabel('03 · Transferencia electrónica')).toBe('Transferencia electrónica · 03')
+        expect(friendlyOptionLabel('G03 · Gastos en general')).toBe('Gastos en general · G03')
+        expect(friendlyOptionLabel('PUE · Pago en una sola exhibición')).toBe('PUE · Pago en una sola exhibición')
+        expect(friendlyOptionLabel('Efectivo')).toBe('Efectivo')
+    })
+})
+
+describe('layout y renglones', () => {
+    it('isEditorLayout solo con layout: editor', () => {
+        expect(isEditorLayout({ layout: 'editor' })).toBe(true)
+        expect(isEditorLayout({ layout: 'wizard' })).toBe(false)
+        expect(isEditorLayout({})).toBe(false)
+    })
+    it('allocation usa `allocations` por defecto; el manifest manda', () => {
+        const base = { key: 'p', label: 'P', fields: [] }
+        expect(editorLinesConfig({ ...base, lines: { kind: 'allocation' } }, {})?.field).toBe('allocations')
+        expect(editorLinesConfig({ ...base, lines: true }, { lines_field: 'items' })?.field).toBe('items')
+        expect(editorLinesConfig(base, {})).toBeUndefined()
+    })
+})
+
+describe('contraparte', () => {
+    const customer = { name: 'Llantas SA', currency_code: 'MXN', tax_id: 'XAXX010101000', fiscal_data: { uso_cfdi: 'G03', regimen: '601' } }
+    it('copia extensiones con la misma clave y no pisa lo capturado', () => {
+        const keys = ['customer_id', 'fiscal_data.uso_cfdi', 'fiscal_data.metodo_pago']
+        expect(partyDefaults(customer, keys, {})).toEqual({ 'fiscal_data.uso_cfdi': 'G03', currency_code: 'MXN' })
+        expect(partyDefaults(customer, keys, { 'fiscal_data.uso_cfdi': 'S01', currency_code: 'USD' })).toEqual({})
+    })
+    it('tarjeta: resumen + extensiones con etiqueta legible', () => {
+        const rows = partySummaryRows(customer, ['tax_id'], { 'fiscal_data.uso_cfdi': 'Uso CFDI' })
+        expect(rows.map((r) => r.key)).toEqual(['tax_id', 'fiscal_data.uso_cfdi', 'fiscal_data.regimen'])
+        expect(rows[1].label).toBe('Uso CFDI')
+    })
+    const cols = { limit: 'credit_limit', balance: 'balance_due', overdue: 'overdue_amount', hold_reason: 'credit_hold_reason' }
+    it('crédito: bloquea si el total supera lo disponible, avisa con vencido, null sin columnas', () => {
+        expect(creditStatus({ credit_limit: 10000, balance_due: 9000 }, cols, 2000)?.level).toBe('block')
+        expect(creditStatus({ credit_limit: 10000, balance_due: 100, overdue_amount: 50 }, cols, 100)?.level).toBe('warn')
+        expect(creditStatus({ name: 'x' }, cols, 1)).toBeNull()
+    })
+})
+
+describe('linesFromSource', () => {
+    it('SalesOrderItem: product_name → description y tasa derivada de tax/subtotal', () => {
+        const [l] = linesFromSource([{ product_id: 'p1', product_name: 'Llanta 205/55R16', quantity: 4, unit_price: 1500, subtotal: 6000, tax_amount: 960 }])
+        expect(l).toMatchObject({ description: 'Llanta 205/55R16', tax_rate: 0.16, quantity: 4, product_id: 'p1' })
+    })
+    it('map traduce nombres (discount_pct) y la tasa 16 se normaliza a 0.16', () => {
+        const [l] = linesFromSource([{ description: 'Balanceo', quantity: 1, unit_price: 100, discount_pct: 10, tax_rate: 16 }], { discount: 'discount_pct' })
+        expect(l.discount).toBe(10)
+        expect(l.tax_rate).toBe(0.16)
+    })
+    it('NC (credit): la cantidad queda topada en lo facturado', () => {
+        const [l] = linesFromSource([{ description: 'Llanta', quantity: 4, unit_price: 1500, tax_rate: 0.16 }], {}, { kind: 'credit' })
+        expect(l.max_quantity).toBe(4)
+    })
+})
+
+describe('localIssues', () => {
+    it('sin renglones es error; precio en cero es aviso; sin ruido por renglón libre', () => {
+        expect(localIssues([]).some((i) => i.severity === 'error')).toBe(true)
+        const w = localIssues([makeLine({ description: 'Servicio' })])
+        expect(w).toEqual([expect.objectContaining({ severity: 'warning', message: 'Renglón 1: precio en cero.' })])
+        expect(localIssues([], { requireLines: false })).toEqual([])
+    })
+})
+
+describe('cobro / REP (allocation)', () => {
+    const cfg: DocumentFormOpenDocuments = {
+        model: 'customers.Invoice',
+        party_field: 'customer_id',
+        balance_field: 'amount_due',
+        number_field: 'number',
+        total_field: 'total',
+        due_field: 'due_date',
+        issued_field: 'issue_date',
+        method_field: 'fiscal_data.metodo_pago',
+        line_document_field: 'invoice_id',
+        line_amount_field: 'amount',
+        option_filter: [{ field: 'status', not_in: ['cancelled'] }],
+    }
+    const rows = [
+        { id: 'a', number: 'A-2', total: 1000, amount_due: 1000, issue_date: '2026-09-01', due_date: '2026-10-01', status: 'open', fiscal_data: { metodo_pago: 'PPD' } },
+        { id: 'b', number: 'A-1', total: 500, amount_due: 300, issue_date: '2026-08-01', due_date: '2026-09-01', status: 'open' },
+        { id: 'c', number: 'A-0', total: 800, amount_due: 0, issue_date: '2026-07-01', status: 'paid' },
+        { id: 'd', number: 'A-9', total: 900, amount_due: 900, issue_date: '2026-07-01', status: 'cancelled' },
+    ]
+
+    it('toOpenDocuments: solo con saldo y que pasan el option_filter', () => {
+        const docs = toOpenDocuments(rows, cfg, 'MXN')
+        expect(docs.map((d) => d.id)).toEqual(['a', 'b'])
+        expect(docs[0]).toMatchObject({ number: 'A-2', balance: 1000, total: 1000, due_at: '2026-10-01', payment_method: 'PPD', currency: 'MXN' })
+    })
+
+    it('reparte del más vencido y arma el payload con los campos de la acción', () => {
+        const docs = toOpenDocuments(rows, cfg, 'MXN')
+        const r = allocatePayment(800, docs)
+        expect(r.allocations.map((a) => [a.document_id, a.amount])).toEqual([['b', 300], ['a', 500]])
+        expect(allocationPayload(r.allocations, cfg)).toEqual([
+            { invoice_id: 'b', amount: 300 },
+            { invoice_id: 'a', amount: 500 },
+        ])
+    })
+
+    it('mensajes claros con el número del documento', () => {
+        const docs = toOpenDocuments(rows, cfg, 'MXN')
+        const issues = validateAllocation(100, 'MXN', docs, [{ document_id: 'b', amount: 400, balance_before: 300, balance_after: 0, installment: 1 }])
+        const msgs = allocationIssueMessages(issues, docs).map((m) => m.message)
+        expect(msgs).toContain('A-1: Se aplica más que el saldo del documento.')
+        expect(msgs).toContain('Lo aplicado supera el monto recibido.')
+    })
+
+    it('campo del monto: `amount` o el primer numérico', () => {
+        expect(allocationAmountField([{ key: 'x', label: '', type: 'text' }, { key: 'amount', label: '', type: 'number' }])).toBe('amount')
+        expect(allocationAmountField([{ key: 'total_paid', label: '', type: 'number' }])).toBe('total_paid')
+    })
+
+    it('días de atraso', () => {
+        expect(overdueDays({ due_at: '2026-10-01' }, new Date(2026, 9, 6))).toBe(5)
+        expect(overdueDays({ due_at: '2026-10-30' }, new Date(2026, 9, 6))).toBe(0)
+        expect(overdueDays({ due_at: null })).toBe(0)
+    })
+})

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

@@ -0,0 +1,261 @@
+// @vitest-environment happy-dom
+// DocumentEditor (layout: "editor"): una pantalla por secciones, «Opciones
+// fiscales» plegadas, una sola acción primaria, prefill desde el origen y
+// reparto de cobros con PaymentAllocator.
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react'
+
+vi.mock('@tanstack/react-router', () => ({ useNavigate: () => () => {} }))
+vi.mock('react-i18next', () => {
+    const i18n = { language: 'es' }
+    const t = (k: string, o?: Record<string, any>) => {
+        let s: string = o?.defaultValue ?? k
+        for (const [key, v] of Object.entries(o ?? {})) s = s.replace(`{{${key}}}`, String(v))
+        return s
+    }
+    const value = { t, i18n }
+    return { useTranslation: () => value }
+})
+
+import { DocumentEditor } from '../business/document-editor'
+import { DocumentFormDialog } from '../document-form-dialog'
+import { ApiProvider, type ApiClient } from '../api-context'
+import { __resetContributions, registerDocumentContribution } from '../primitives/contributions'
+import type { DocumentFormsManifest, DocumentFormType } from '../types'
+
+afterEach(() => {
+    cleanup()
+    __resetContributions()
+})
+
+type Routes = Record<string, unknown>
+
+function makeApi(routes: Routes = {}, post = vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'new-1' } } })) {
+    const get = vi.fn(async (url: string, cfg?: { params?: Record<string, unknown> }) => {
+        for (const [prefix, body] of Object.entries(routes)) {
+            if (url.startsWith(prefix)) return { data: typeof body === 'function' ? (body as any)(url, cfg) : body }
+        }
+        return { data: { data: [] } }
+    })
+    const client = { get, post, put: vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'new-1' } } }), delete: vi.fn() }
+    return { client: client as unknown as ApiClient, get, post }
+}
+
+const invoice: DocumentFormType = {
+    key: 'invoice',
+    label: 'Factura',
+    value: 'I',
+    layout: 'editor',
+    fields: [
+        { key: 'customer_name', label: 'Cliente', type: 'text', required: true },
+        { key: 'payment_form', label: 'Forma de pago', type: 'select', required: true, defaultValue: '03', options: [{ value: '03', label: '03 · Transferencia' }, { value: '01', label: '01 · Efectivo' }] },
+        { key: 'payment_method', label: 'Método de pago', type: 'select', defaultValue: 'PUE', options: [{ value: 'PUE', label: 'PUE · Una exhibición' }, { value: 'PPD', label: 'PPD · Parcialidades' }] },
+        { key: 'sales_order_id', label: 'Venta', type: 'text' },
+    ],
+    lines: { columns: ['tax'] },
+    sources: [{ key: 'sales_order', label: 'Venta', model: 'customers.SalesOrder', lines: 'items', map: { description: 'product_name' }, link_field: 'sales_order_id' }],
+    preview: { action: 'preview_cfdi', label: 'Vista previa CFDI' },
+    submit_label: 'Guardar factura',
+}
+const forms: DocumentFormsManifest = { type_field: 'type', types: [invoice] }
+
+function renderEditor(type: DocumentFormType, api: ReturnType<typeof makeApi>, extra: Partial<Parameters<typeof DocumentEditor>[0]> = {}) {
+    const onSaved = vi.fn()
+    render(
+        <ApiProvider client={api.client}>
+            <DocumentEditor model="customers.Invoice" forms={{ ...forms, types: [type] }} type={type} onCancel={() => {}} onSaved={onSaved} currency="MXN" {...extra} />
+        </ApiProvider>,
+    )
+    return { onSaved }
+}
+
+describe('DocumentEditor — divulgación progresiva', () => {
+    it('«Opciones fiscales» arranca plegada: lo esencial a la vista, el método con default adentro', () => {
+        renderEditor(invoice, makeApi())
+        const toggle = screen.getByRole('button', { name: /Opciones fiscales/ })
+        expect(toggle.getAttribute('aria-expanded')).toBe('false')
+        const panel = document.getElementById(toggle.getAttribute('aria-controls')!)!
+        expect(panel.hidden).toBe(true)
+        expect(within(panel).getByText('Método de pago')).toBeTruthy()
+        // Esencial: fuera de la sección plegada.
+        const essentials = document.querySelector('[data-slot="editor-essentials"]')!
+        expect(within(essentials as HTMLElement).getByText('Cliente')).toBeTruthy()
+        expect(within(essentials as HTMLElement).getByText('Forma de pago')).toBeTruthy()
+        expect(within(essentials as HTMLElement).queryByText('Método de pago')).toBeNull()
+        // Resumen de los defaults sin abrir.
+        expect(toggle.textContent).toContain('PUE')
+        fireEvent.click(toggle)
+        expect(toggle.getAttribute('aria-expanded')).toBe('true')
+        expect(panel.hidden).toBe(false)
+    })
+
+    it('la vista previa es opcional y está cerrada por defecto', () => {
+        renderEditor(invoice, makeApi())
+        expect(screen.getByRole('button', { name: /Vista previa CFDI/ }).getAttribute('aria-expanded')).toBe('false')
+    })
+
+    it('las etiquetas muestran el código SAT como dato secundario', () => {
+        renderEditor(invoice, makeApi())
+        expect(screen.getAllByText('Transferencia · 03').length).toBeGreaterThan(0)
+    })
+
+    it('una contribución header.fields de otro addon entra en «Opciones fiscales»', () => {
+        registerDocumentContribution({
+            id: 'fiscal_mexico.header.cfdi',
+            kinds: ['invoice'],
+            region: 'header.fields',
+            requiresAddon: 'fiscal_mexico',
+            component: () => <p>Relación CFDI</p>,
+        })
+        renderEditor(invoice, makeApi())
+        const panel = document.querySelector('[data-slot="advanced-options"]')!
+        expect(within(panel as HTMLElement).getByText('Relación CFDI')).toBeTruthy()
+    })
+})
+
+describe('DocumentEditor — una sola acción primaria', () => {
+    it('un solo botón primario (submit_label) y sin «Siguiente»', () => {
+        renderEditor(invoice, makeApi())
+        const primaries = document.querySelectorAll('[data-slot="document-editor"] [data-primary="true"]')
+        expect(primaries.length).toBe(1)
+        expect(primaries[0].textContent).toBe('Guardar factura')
+        expect(screen.queryByRole('button', { name: 'Siguiente' })).toBeNull()
+    })
+
+    it('sin renglones no guarda: validación inline y revisión visible', async () => {
+        const api = makeApi()
+        renderEditor(invoice, api)
+        fireEvent.click(screen.getByRole('button', { name: 'Guardar factura' }))
+        await screen.findByText('Agrega al menos un renglón.')
+        expect(screen.getAllByText(/Cliente/).length).toBeGreaterThan(1) // etiqueta + error inline
+        expect(api.post).not.toHaveBeenCalled()
+    })
+})
+
+describe('DocumentEditor — prefill desde el documento origen', () => {
+    it('initialSource carga los renglones y el vínculo; guarda con el tipo y los renglones serializados', async () => {
+        const api = makeApi({
+            '/metadata/table/customers.SalesOrder': { data: { relations: [{ name: 'items', kind: 'one_to_many', through: 'customers.SalesOrderItem', foreign_key: 'sales_order_id' }] } },
+            '/data/customers.SalesOrderItem': { data: [{ product_id: 'p1', product_name: 'Llanta 205/55R16', quantity: 4, unit_price: 1500, tax_rate: 0.16 }] },
+            '/data/customers.SalesOrder': { data: [{ id: 'so-1', customer_name: 'ACME' }] },
+        })
+        const { onSaved } = renderEditor(
+            { ...invoice, sources: [{ ...invoice.sources![0], header: { customer_name: 'customer_name' } }] },
+            api,
+            { initialSource: { key: 'sales_order', id: 'so-1' } },
+        )
+        await screen.findByDisplayValue('Llanta 205/55R16')
+        await screen.findByDisplayValue('ACME')
+        expect(api.get).toHaveBeenCalledWith('/data/customers.SalesOrderItem', expect.objectContaining({ params: expect.objectContaining({ f_sales_order_id: 'eq:so-1' }) }))
+        fireEvent.click(screen.getByRole('button', { name: 'Guardar factura' }))
+        await waitFor(() => expect(api.post).toHaveBeenCalled())
+        const [url, body] = api.post.mock.calls[0] as [string, any]
+        expect(url).toBe('/dynamic/customers.Invoice')
+        expect(body).toMatchObject({ type: 'I', customer_name: 'ACME', sales_order_id: 'so-1', payment_method: 'PUE', payment_form: '03' })
+        expect(body.lines).toEqual([expect.objectContaining({ product_id: 'p1', description: 'Llanta 205/55R16', quantity: 4, unit_price: 1500 })])
+        await waitFor(() => expect(onSaved).toHaveBeenCalledWith(expect.objectContaining({ id: 'new-1' })))
+    })
+
+    it('default_from_record siembra el encabezado desde el registro de la acción', () => {
+        const type: DocumentFormType = {
+            ...invoice,
+            fields: [{ key: 'customer_name', label: 'Cliente', type: 'text', default_from_record: 'name' } as any],
+        }
+        renderEditor(type, makeApi(), { record: { id: 'c1', name: 'Taller Pérez' } })
+        expect(screen.getByDisplayValue('Taller Pérez')).toBeTruthy()
+    })
+})
+
+describe('DocumentEditor — cobro / REP (lines.kind: allocation)', () => {
+    const payment: DocumentFormType = {
+        key: 'payment',
+        label: 'Registrar cobro',
+        layout: 'editor',
+        submit_action: 'collect_multi_payment_create',
+        submit_label: 'Registrar cobro',
+        party: { field: 'customer_id', model: 'customers.Customer' },
+        fields: [
+            { key: 'customer_id', label: 'Cliente', type: 'text', required: true, default_from_record: 'customer_id' } as any,
+            { key: 'amount', label: 'Monto recibido', type: 'number', required: true },
+        ],
+        lines: {
+            kind: 'allocation',
+            open_documents: {
+                model: 'customers.Invoice',
+                party_field: 'customer_id',
+                balance_field: 'amount_due',
+                number_field: 'number',
+                due_field: 'due_date',
+                issued_field: 'issue_date',
+                line_document_field: 'invoice_id',
+                line_amount_field: 'amount',
+            },
+        },
+    }
+    const routes = {
+        '/data/customers.Customer': { data: [{ id: 'c1', name: 'Llantas SA' }] },
+        '/data/customers.Invoice': {
+            data: [
+                { id: 'inv-new', number: 'A-2', amount_due: 1000, issue_date: '2026-09-01', due_date: '2026-10-30' },
+                { id: 'inv-old', number: 'A-1', amount_due: 300, issue_date: '2026-08-01', due_date: '2026-09-01' },
+            ],
+        },
+    }
+
+    it('lista las facturas abiertas, reparte del más vencido y guarda por la acción con allocations', async () => {
+        const api = makeApi(routes)
+        renderEditor(payment, api, { record: { customer_id: 'c1' }, today: new Date(2026, 9, 6) })
+        await screen.findByText('A-1')
+        expect(api.get).toHaveBeenCalledWith('/data/customers.Invoice', expect.objectContaining({ params: expect.objectContaining({ f_customer_id: 'eq:c1' }) }))
+        expect(await screen.findByText('Llantas SA')).toBeTruthy()
+        fireEvent.change(document.querySelector('[data-slot="editor-essentials"] input[type=number]')!, { target: { value: '500' } })
+        await waitFor(() => expect((screen.getByLabelText('Aplicar a A-1') as HTMLInputElement).value).toBe('300'))
+        expect((screen.getByLabelText('Aplicar a A-2') as HTMLInputElement).value).toBe('200')
+        expect(screen.getByText(/Parcialidad 1/)).toBeTruthy()
+        fireEvent.click(screen.getByRole('button', { name: 'Registrar cobro' }))
+        await waitFor(() => expect(api.post).toHaveBeenCalled())
+        const [url, body] = api.post.mock.calls[0] as [string, any]
+        expect(url).toBe('/dynamic/customers.Invoice/action/collect_multi_payment_create')
+        expect(body).toMatchObject({ customer_id: 'c1', amount: 500 })
+        expect(body.allocations).toEqual([
+            { invoice_id: 'inv-old', amount: 300 },
+            { invoice_id: 'inv-new', amount: 200 },
+        ])
+        expect(body.type).toBeUndefined()
+    })
+
+    it('editar un monto pasa a reparto manual; «Autoaplicar» regresa al automático', async () => {
+        const api = makeApi(routes)
+        renderEditor(payment, api, { record: { customer_id: 'c1' } })
+        await screen.findByText('A-1')
+        fireEvent.click(screen.getByRole('button', { name: /Cobrar todo/ }))
+        await waitFor(() => expect((screen.getByLabelText('Aplicar a A-2') as HTMLInputElement).value).toBe('1000'))
+        fireEvent.change(screen.getByLabelText('Aplicar a A-2'), { target: { value: '400' } })
+        expect(screen.getByText('Reparto manual')).toBeTruthy()
+        expect((screen.getByLabelText('Aplicar a A-2') as HTMLInputElement).value).toBe('400')
+        expect(screen.getByText('Sin aplicar (saldo a favor)')).toBeTruthy()
+        fireEvent.click(screen.getByRole('button', { name: 'Autoaplicar' }))
+        expect((screen.getByLabelText('Aplicar a A-2') as HTMLInputElement).value).toBe('1000')
+    })
+})
+
+describe('DocumentFormDialog + layout: editor', () => {
+    it('con layout editor abre el DocumentEditor; sin él sigue el wizard', () => {
+        const api = makeApi()
+        const { unmount } = render(
+            <ApiProvider client={api.client}>
+                <DocumentFormDialog open onOpenChange={() => {}} model="customers.Invoice" forms={forms} />
+            </ApiProvider>,
+        )
+        expect(document.querySelector('[data-slot="document-editor"]')).toBeTruthy()
+        expect(screen.queryByRole('button', { name: 'Siguiente' })).toBeNull()
+        unmount()
+        render(
+            <ApiProvider client={api.client}>
+                <DocumentFormDialog open onOpenChange={() => {}} model="customers.Invoice" forms={{ ...forms, types: [{ ...invoice, layout: undefined }] }} />
+            </ApiProvider>,
+        )
+        expect(document.querySelector('[data-slot="document-editor"]')).toBeNull()
+        expect(screen.getByRole('button', { name: 'Siguiente' })).toBeTruthy()
+    })
+})

package/src/__tests__/document-form-dialog.test.tsx

@@ -12,10 +12,11 @@ vi.mock('react-i18next', () => {
     return { useTranslation: () => value }
 })
 
-import { DocumentFormDialog, resolveDocumentForms } from '../document-form-dialog'
+import { DocumentFormDialog, resolveDocumentForms, scopeDocumentFormsToFilter } from '../document-form-dialog'
 import { DynamicCRUDPage } from '../dynamic-crud-page'
 import { useMetadataCache } from '../metadata-cache'
 import { ApiProvider, type ApiClient } from '../api-context'
+import { OrgRuntimeProvider } from '../org-runtime-provider'
 import type { DocumentFormsManifest } from '../types'
 
 afterEach(cleanup)
@@ -128,6 +129,84 @@ describe('DocumentFormDialog', () => {
     })
 })
 
+// Retest Pitsline 05/10: Facturas → Crear guardaba la factura en $0 porque el
+// host (DynamicCRUDPage / ops) no pasa `searchProducts` y el paso de renglones
+// solo ofrecía «Renglón libre» sin precio.
+describe('DocumentFormDialog: buscador de catálogo por defecto', () => {
+    const invoiceOnly: DocumentFormsManifest = { ...forms, types: [forms.types[0]] }
+    const catalogRow = {
+        id: 'prod-1',
+        name: 'Llanta 205/55R16',
+        sku: 'LL-205',
+        unit_price: '1500.00',
+        cost_price: '900',
+        unit_of_measure: 'pza',
+        product_type: 'product',
+        fiscal_data: { mx_clave_prod_serv: '25172504', mx_clave_unidad: 'H87' },
+    }
+
+    function mount(opts: { searchProducts?: any; taxRate?: number } = {}) {
+        const get = vi.fn().mockResolvedValue({ data: { success: true, data: [catalogRow] } })
+        const post = vi.fn().mockResolvedValue({ data: { success: true, data: { id: 'inv-1' } } })
+        const client = { get, post, put: vi.fn(), delete: vi.fn() } as unknown as ApiClient
+        render(
+            <ApiProvider client={client}>
+                <OrgRuntimeProvider taxRate={opts.taxRate}>
+                    <DocumentFormDialog
+                        open
+                        onOpenChange={vi.fn()}
+                        model="customers.Invoice"
+                        forms={invoiceOnly}
+                        searchProducts={opts.searchProducts}
+                    />
+                </OrgRuntimeProvider>
+            </ApiProvider>,
+        )
+        return { get, post }
+    }
+
+    async function pickFirstProduct(query: string, name: RegExp) {
+        fireEvent.change(document.querySelectorAll('input')[0], { target: { value: 'ACME' } })
+        fireEvent.click(screen.getByRole('button', { name: 'Siguiente' }))
+        fireEvent.change(await screen.findByLabelText('Buscar producto'), { target: { value: query } })
+        fireEvent.click(await waitFor(() => screen.getByRole('button', { name }), { timeout: 2000 }))
+    }
+
+    it('sin searchProducts del host busca en el catálogo y el renglón entra con precio, cantidad 1, unidad, SKU e IVA de la org', async () => {
+        const { get, post } = mount({ taxRate: 0.16 })
+        await pickFirstProduct('llanta', /Llanta 205\/55R16/)
+        expect(get).toHaveBeenCalledWith(
+            '/data/products.Product',
+            expect.objectContaining({ params: expect.objectContaining({ search: 'llanta' }) }),
+        )
+        fireEvent.click(screen.getByRole('button', { name: 'Crear' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        const [line] = (post.mock.calls[0][1] as any).lines
+        expect(line).toMatchObject({
+            product_id: 'prod-1',
+            sku: 'LL-205',
+            description: 'Llanta 205/55R16',
+            quantity: 1,
+            unit_price: 1500,
+            tax_rate: 0.16,
+            unit: 'pza',
+            fiscal_data: { mx_clave_prod_serv: '25172504', mx_clave_unidad: 'H87' },
+        })
+        expect(line.unit_price).toBeGreaterThan(0)
+    })
+
+    it('si el host pasa searchProducts, se usa ese y no el catálogo', async () => {
+        const searchProducts = vi.fn(async () => [{ id: 'h1', name: 'Servicio host', price: 250, tax_rate: 0.08 }])
+        const { get, post } = mount({ searchProducts })
+        await pickFirstProduct('serv', /Servicio host/)
+        expect(searchProducts).toHaveBeenCalled()
+        expect(get).not.toHaveBeenCalledWith('/data/products.Product', expect.anything())
+        fireEvent.click(screen.getByRole('button', { name: 'Crear' }))
+        await waitFor(() => expect(post).toHaveBeenCalled())
+        expect((post.mock.calls[0][1] as any).lines[0]).toMatchObject({ product_id: 'h1', quantity: 1, unit_price: 250, tax_rate: 0.08 })
+    })
+})
+
 describe('resolveDocumentForms', () => {
     it('sin manifest (o sin tipos) devuelve undefined: el alta genérica sigue igual', () => {
         expect(resolveDocumentForms(null)).toBeUndefined()
@@ -157,7 +236,7 @@ describe('DynamicCRUDPage + document_forms', () => {
             ...extra,
         }) as any
 
-    const mount = (m: any) => {
+    const mount = (m: any, filter?: Record<string, string>) => {
         useMetadataCache.getState().setMetadata('fiscal_documents', m)
         const client = {
             get: vi.fn(async (url: string) =>
@@ -169,7 +248,7 @@ describe('DynamicCRUDPage + document_forms', () => {
         } as unknown as ApiClient
         render(
             <ApiProvider client={client}>
-                <DynamicCRUDPage model="fiscal_documents" />
+                <DynamicCRUDPage model="fiscal_documents" filter={filter} />
             </ApiProvider>,
         )
     }
@@ -187,4 +266,40 @@ describe('DynamicCRUDPage + document_forms', () => {
         await new Promise((r) => setTimeout(r, 50))
         expect(screen.queryByRole('radiogroup')).toBeNull()
     })
+
+    // Retest r3 (05/10): «Documentos fiscales → Facturas» (nav filtrado por el
+    // type_field) ofrecía Crear y abría el REP, el único tipo declarado.
+    it('vista filtrada a un tipo sin formulario: sin botón Crear', async () => {
+        mount(meta({ document_forms: forms }), { type: 'P' })
+        await screen.findByText(/Nota/)
+        await new Promise((r) => setTimeout(r, 50))
+        expect(screen.queryByText(/New Nota/)).toBeNull()
+    })
+
+    it('vista filtrada a un tipo con formulario: Crear abre ese tipo directo', async () => {
+        mount(meta({ document_forms: forms }), { type: 'eq:E' })
+        fireEvent.click((await screen.findByText(/New Nota/)).closest('button')!)
+        expect(await screen.findByText('Factura origen')).toBeTruthy()
+        expect(screen.queryByRole('radiogroup')).toBeNull()
+    })
+})
+
+describe('scopeDocumentFormsToFilter', () => {
+    it('sin filtro sobre el type_field no cambia nada', () => {
+        expect(scopeDocumentFormsToFilter(forms, undefined)).toEqual({ forms, hideCreate: false })
+        expect(scopeDocumentFormsToFilter(forms, { status: 'draft' })).toEqual({ forms, hideCreate: false })
+        expect(scopeDocumentFormsToFilter(undefined, { type: 'I' })).toEqual({ forms: undefined, hideCreate: false })
+        expect(scopeDocumentFormsToFilter({ ...forms, type_field: undefined }, { type: 'X' }).hideCreate).toBe(false)
+    })
+
+    it('acota al tipo del filtro (valor o key, sin importar mayúsculas ni eq:)', () => {
+        expect(scopeDocumentFormsToFilter(forms, { type: 'e' }).forms?.types.map((x) => x.key)).toEqual(['credit_note'])
+        expect(scopeDocumentFormsToFilter(forms, { type: 'eq:I' }).forms?.types.map((x) => x.key)).toEqual(['invoice'])
+        const noValue: DocumentFormsManifest = { type_field: 'document_type', types: [{ key: 'payment_complement', label: 'REP', fields: [] }] }
+        expect(scopeDocumentFormsToFilter(noValue, { document_type: 'payment_complement' }).forms).toBe(noValue)
+    })
+
+    it('filtro a un tipo sin formulario: oculta Crear', () => {
+        expect(scopeDocumentFormsToFilter(forms, { type: 'P' })).toEqual({ forms: undefined, hideCreate: true })
+    })
 })