@asteby/metacore-runtime-react 46.0.0 → 46.2.0

package/src/business/inspection.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest'
+import {
+    makeInspectionPoint,
+    parseInspectionPoints,
+    recommendationsToLines,
+    serializeInspectionPoints,
+    summarizeInspection,
+    treadStatus,
+    validateInspection,
+    worstStatus,
+} from './inspection'
+
+const pt = (p: Parameters<typeof makeInspectionPoint>[0]) => makeInspectionPoint({ section: 'Llantas', ...p })
+
+describe('inspection · semáforo', () => {
+    it('la profundidad de dibujo fija el color con los umbrales dados', () => {
+        expect(treadStatus(null)).toBe('pending')
+        expect(treadStatus(1.5)).toBe('urgent')
+        expect(treadStatus(1.6)).toBe('attention')
+        expect(treadStatus(2.9)).toBe('attention')
+        expect(treadStatus(3)).toBe('ok')
+        expect(treadStatus(4, { urgent: 2, attention: 5 })).toBe('attention')
+    })
+    it('el peor estado gana: rojo > amarillo > verde > pendiente', () => {
+        expect(worstStatus([])).toBe('pending')
+        expect(worstStatus([pt({ status: 'ok' }), pt({ status: 'attention' })])).toBe('attention')
+        expect(worstStatus([pt({ status: 'urgent' }), pt({ status: 'attention' }), pt({ status: 'ok' })])).toBe('urgent')
+    })
+    it('resume conteos y total recomendado (solo puntos con recomendación)', () => {
+        const s = summarizeInspection([
+            pt({ name: 'a', status: 'ok' }),
+            pt({ name: 'b', status: 'attention', recommendation: 'Cambiar balatas', quantity: 2, unit_price: 350.5 }),
+            pt({ name: 'c', status: 'urgent', notes: 'sin recomendación', unit_price: 999 }),
+            pt({ name: 'd' }),
+        ])
+        expect(s.counts).toEqual({ pending: 1, ok: 1, attention: 1, urgent: 1 })
+        expect(s.worst).toBe('urgent')
+        expect(s.recommendations).toBe(1)
+        expect(s.recommendedTotal).toBe(701)
+    })
+})
+
+describe('inspection · validación', () => {
+    it('un punto en verde no lleva recomendación y no hay medidas negativas', () => {
+        const v = validateInspection([
+            pt({ name: 'ok', status: 'ok', recommendation: 'algo' }),
+            pt({ name: 'mm', kind: 'tread', value: -1, status: 'urgent' }),
+        ])
+        expect(v.ok).toBe(false)
+        expect(v.errors['0.recommendation']).toBeTruthy()
+        expect(v.errors['1.value']).toBeTruthy()
+    })
+    it('exige revisar todo y el kilometraje solo cuando la regla lo pide', () => {
+        const points = [pt({ name: 'a', status: 'ok' }), pt({ name: 'b' })]
+        expect(validateInspection(points).ok).toBe(true)
+        expect(validateInspection(points, undefined, { requireAllReviewed: true }).form).toMatch(/revisar/)
+        expect(validateInspection([], { damage_notes: '' }, { requireOdometer: true }).ok).toBe(false)
+        expect(validateInspection([], { damage_notes: '', odometer_km: 0 }, { requireOdometer: true }).ok).toBe(true)
+    })
+    it('una alerta sin nota, recomendación ni foto se marca si la regla lo pide', () => {
+        const v = validateInspection([pt({ name: 'a', status: 'urgent' })], undefined, { requireEvidenceOnIssues: true })
+        expect(v.errors['0.notes']).toBeTruthy()
+        const withPhoto = pt({ name: 'a', status: 'urgent', media: [{ key: 'm', url: '/x.jpg', type: 'photo' }] })
+        expect(validateInspection([withPhoto], undefined, { requireEvidenceOnIssues: true }).ok).toBe(true)
+    })
+})
+
+describe('inspection · serialización', () => {
+    it('serializa números reales, line_no 1-based y sin claves de UI', () => {
+        const [row] = serializeInspectionPoints([
+            pt({
+                id: 'abc',
+                name: '  Llanta FL ',
+                kind: 'tread',
+                value: 2.4,
+                unit: 'mm',
+                status: 'attention',
+                recommendation: ' Cambiar ',
+                quantity: 1,
+                unit_price: 1800,
+                media: [{ key: 'k', url: '/u/1.jpg', type: 'photo' }],
+            }),
+        ])
+        expect(row).toMatchObject({
+            id: 'abc',
+            line_no: 1,
+            name: 'Llanta FL',
+            measure_value: 2.4,
+            unit: 'mm',
+            recommendation: 'Cambiar',
+            unit_price: 1800,
+            media: [{ url: '/u/1.jpg', type: 'photo' }],
+        })
+        expect(row).not.toHaveProperty('key')
+        const [empty] = serializeInspectionPoints([pt({ name: 'x' })])
+        expect(empty).not.toHaveProperty('measure_value')
+        expect(empty).not.toHaveProperty('id')
+    })
+    it('parse es la inversa y tolera basura', () => {
+        expect(parseInspectionPoints(null)).toEqual([])
+        const [p] = parseInspectionPoints([
+            { id: 'i', name: 'Frenos', section: 'Frenos', kind: 'measure', status: 'urgent', measure_value: '3.5', unit: 'mm', quantity: '2', unit_price: '10.5', approval: 'declined', media: [{ url: '/v.mp4', type: 'video' }] },
+        ])
+        expect(p).toMatchObject({ id: 'i', kind: 'measure', status: 'urgent', value: 3.5, quantity: 2, unit_price: 10.5, approval: 'declined' })
+        expect(p.media[0]).toMatchObject({ url: '/v.mp4', type: 'video' })
+        const [bad] = parseInspectionPoints([{ status: 'rojo', kind: 'raro' }])
+        expect(bad.status).toBe('pending')
+        expect(bad.kind).toBe('check')
+    })
+})
+
+describe('inspection · recomendación → renglón', () => {
+    it('convierte solo los puntos con recomendación y filtra por respuesta del cliente', () => {
+        const points = [
+            pt({ name: 'Balatas', recommendation: 'Cambiar', quantity: 2, unit_price: 400, status: 'urgent', approval: 'approved' }),
+            pt({ name: 'Aceite', recommendation: 'Cambio', unit_price: 900, status: 'attention', approval: 'declined' }),
+            pt({ name: 'Luces', status: 'ok' }),
+        ]
+        const all = recommendationsToLines(points)
+        expect(all.map((l) => l.description)).toEqual(['Balatas — Cambiar', 'Aceite — Cambio'])
+        expect(all[0]).toMatchObject({ kind: 'item', quantity: 2, unit_price: 400 })
+        expect(recommendationsToLines(points, { approval: ['approved'] })).toHaveLength(1)
+        expect(recommendationsToLines(points, { approval: ['declined'] })[0].description).toBe('Aceite — Cambio')
+    })
+})

package/src/business/inspection.ts

@@ -0,0 +1,281 @@
+// Inspección con checklist (recepción de vehículo, inspección multipunto, OT,
+// alineación, garantía): lógica pura del <InspectionChecklist> (benchmark §7,
+// TAL-4/TAL-5). El semáforo, el resumen y la salida hacia el backend viven aquí
+// para que el componente y los addons (que guardan por una acción) coincidan.
+import { makeLine, type LineItem } from './line-items'
+import { roundMoney, toAmount } from './format'
+
+/** Semáforo de un punto: pendiente (sin revisar), verde, amarillo, rojo. */
+export type InspectionStatus = 'pending' | 'ok' | 'attention' | 'urgent'
+
+/**
+ * Qué captura el punto: `check` solo el semáforo; `tread` profundidad de dibujo
+ * en mm (el semáforo sale del valor); `measure` un valor numérico libre con su
+ * unidad. El nivel de combustible y el kilometraje van en el encabezado.
+ */
+export type InspectionPointKind = 'check' | 'tread' | 'measure'
+
+export type InspectionMediaType = 'photo' | 'video'
+
+export interface InspectionMedia {
+    /** Clave estable de UI. */
+    key: string
+    url: string
+    type: InspectionMediaType
+    caption?: string
+}
+
+export interface InspectionPoint {
+    /** Clave estable de UI (no se envía). */
+    key: string
+    /** Id de la fila guardada, si ya existe. */
+    id?: string
+    /** Agrupa los puntos en el checklist («Llantas», «Frenos»...). */
+    section: string
+    name: string
+    kind: InspectionPointKind
+    status: InspectionStatus
+    /** Valor medido (`tread`/`measure`). */
+    value?: number | null
+    unit?: string
+    notes: string
+    /** Trabajo recomendado; con texto, el punto es un renglón candidato. */
+    recommendation: string
+    quantity: number
+    unit_price: number
+    media: InspectionMedia[]
+    /** Respuesta del cliente a la recomendación, cuando ya la dio. */
+    approval?: 'none' | 'pending' | 'approved' | 'declined'
+}
+
+export type FuelLevel = 'empty' | 'quarter' | 'half' | 'three_quarters' | 'full'
+
+export const FUEL_LEVELS: readonly FuelLevel[] = ['empty', 'quarter', 'half', 'three_quarters', 'full']
+
+/** Encabezado de una recepción: lo que se ve al recibir el vehículo. */
+export interface InspectionHeader {
+    odometer_km?: number | null
+    fuel_level?: FuelLevel | ''
+    /** Daños previos visibles, para deslindar responsabilidad. */
+    damage_notes: string
+}
+
+/** Umbrales de profundidad de dibujo en mm (el límite legal común es 1.6). */
+export interface TreadThresholds {
+    /** Por debajo de esto el semáforo es rojo. Default 1.6. */
+    urgent: number
+    /** Por debajo de esto (y sobre `urgent`) es amarillo. Default 3. */
+    attention: number
+}
+
+export const DEFAULT_TREAD_THRESHOLDS: TreadThresholds = { urgent: 1.6, attention: 3 }
+
+let seq = 0
+export function newInspectionKey(prefix = 'ip'): string {
+    seq += 1
+    return `${prefix}-${Date.now().toString(36)}-${seq}`
+}
+
+export function makeInspectionPoint(partial: Partial<InspectionPoint> = {}): InspectionPoint {
+    return {
+        key: partial.key ?? newInspectionKey(),
+        section: '',
+        name: '',
+        kind: 'check',
+        status: 'pending',
+        notes: '',
+        recommendation: '',
+        quantity: 1,
+        unit_price: 0,
+        media: [],
+        ...partial,
+    }
+}
+
+/** Semáforo que le toca a una profundidad de dibujo. Sin valor: `pending`. */
+export function treadStatus(mm: number | null | undefined, th: TreadThresholds = DEFAULT_TREAD_THRESHOLDS): InspectionStatus {
+    if (mm == null || !Number.isFinite(mm)) return 'pending'
+    if (mm < th.urgent) return 'urgent'
+    if (mm < th.attention) return 'attention'
+    return 'ok'
+}
+
+const RANK: Record<InspectionStatus, number> = { pending: 0, ok: 1, attention: 2, urgent: 3 }
+
+/** El peor estado de la lista (rojo > amarillo > verde > pendiente). */
+export function worstStatus(points: Pick<InspectionPoint, 'status'>[]): InspectionStatus {
+    return points.reduce<InspectionStatus>((w, p) => (RANK[p.status] > RANK[w] ? p.status : w), 'pending')
+}
+
+/** ¿El punto trae una recomendación que se puede cotizar? */
+export function hasRecommendation(p: Pick<InspectionPoint, 'recommendation'>): boolean {
+    return p.recommendation.trim() !== ''
+}
+
+export interface InspectionSummary {
+    total: number
+    counts: Record<InspectionStatus, number>
+    worst: InspectionStatus
+    /** Puntos sin revisar. */
+    pending: number
+    /** Puntos con recomendación. */
+    recommendations: number
+    /** Suma cantidad × precio de las recomendaciones. */
+    recommendedTotal: number
+}
+
+export function summarizeInspection(points: InspectionPoint[]): InspectionSummary {
+    const counts: Record<InspectionStatus, number> = { pending: 0, ok: 0, attention: 0, urgent: 0 }
+    let recommendations = 0
+    let recommendedTotal = 0
+    for (const p of points) {
+        counts[p.status] += 1
+        if (hasRecommendation(p)) {
+            recommendations += 1
+            recommendedTotal += p.quantity * p.unit_price
+        }
+    }
+    return {
+        total: points.length,
+        counts,
+        worst: worstStatus(points),
+        pending: counts.pending,
+        recommendations,
+        recommendedTotal: roundMoney(recommendedTotal),
+    }
+}
+
+export interface InspectionValidation {
+    ok: boolean
+    /** Errores por `"<índice>.<campo>"` (mismo contrato que LineItemsEditor). */
+    errors: Record<string, string>
+    /** Error de formulario (encabezado o conjunto). */
+    form?: string
+}
+
+export interface InspectionRules {
+    /** Exige revisar todos los puntos (ninguno `pending`). Default false (borrador). */
+    requireAllReviewed?: boolean
+    /** Exige kilometraje en el encabezado (recepción). Default false. */
+    requireOdometer?: boolean
+    /** Un punto amarillo/rojo debe llevar nota, recomendación o evidencia. Default false. */
+    requireEvidenceOnIssues?: boolean
+}
+
+export function validateInspection(
+    points: InspectionPoint[],
+    header?: InspectionHeader,
+    rules: InspectionRules = {},
+): InspectionValidation {
+    const errors: Record<string, string> = {}
+    points.forEach((p, i) => {
+        if (p.name.trim() === '') errors[`${i}.name`] = 'Falta el nombre del punto'
+        if ((p.kind === 'tread' || p.kind === 'measure') && p.value != null && (!Number.isFinite(p.value) || p.value < 0)) {
+            errors[`${i}.value`] = 'La medición no puede ser negativa'
+        }
+        if (p.quantity < 0 || p.unit_price < 0) errors[`${i}.unit_price`] = 'Cantidad y precio no pueden ser negativos'
+        if (hasRecommendation(p) && p.status === 'ok') {
+            errors[`${i}.recommendation`] = 'Un punto en verde no lleva recomendación'
+        }
+        if (
+            rules.requireEvidenceOnIssues &&
+            (p.status === 'attention' || p.status === 'urgent') &&
+            p.notes.trim() === '' &&
+            !hasRecommendation(p) &&
+            p.media.length === 0
+        ) {
+            errors[`${i}.notes`] = 'Anota, recomienda o agrega una foto'
+        }
+    })
+    let form: string | undefined
+    if (rules.requireAllReviewed && points.some((p) => p.status === 'pending')) {
+        form = 'Faltan puntos por revisar'
+    }
+    if (rules.requireOdometer && header && (header.odometer_km == null || !(header.odometer_km >= 0))) {
+        form = form ?? 'Captura el kilometraje'
+    }
+    return { ok: Object.keys(errors).length === 0 && !form, errors, form }
+}
+
+/**
+ * Única puerta de salida hacia el backend: números reales, sin claves de UI,
+ * opcionales vacíos omitidos y `line_no` 1-based (mismo criterio que
+ * `serializeLineItems`).
+ */
+export function serializeInspectionPoints(points: InspectionPoint[]): Record<string, unknown>[] {
+    return points.map((p, i) => {
+        const o: Record<string, unknown> = {
+            line_no: i + 1,
+            section: p.section.trim(),
+            name: p.name.trim(),
+            kind: p.kind,
+            status: p.status,
+            notes: p.notes.trim(),
+            recommendation: p.recommendation.trim(),
+            quantity: toAmount(p.quantity),
+            unit_price: toAmount(p.unit_price),
+            media: p.media.map((m) => ({ url: m.url, type: m.type, ...(m.caption ? { caption: m.caption } : {}) })),
+        }
+        if (p.id) o.id = p.id
+        if (p.value != null && Number.isFinite(p.value)) o.measure_value = p.value
+        if (p.unit) o.unit = p.unit
+        return o
+    })
+}
+
+/** Inversa de `serializeInspectionPoints`: filas del backend a puntos de UI. */
+export function parseInspectionPoints(rows: unknown): InspectionPoint[] {
+    if (!Array.isArray(rows)) return []
+    const str = (v: unknown) => (typeof v === 'string' ? v : v == null ? '' : String(v))
+    return rows.map((r) => {
+        const o = (r ?? {}) as Record<string, unknown>
+        const status = str(o.status) as InspectionStatus
+        const kind = str(o.kind) as InspectionPointKind
+        const media = Array.isArray(o.media)
+            ? (o.media as Record<string, unknown>[]).map((m) => ({
+                  key: newInspectionKey('im'),
+                  url: str(m.url),
+                  type: (str(m.type) === 'video' ? 'video' : 'photo') as InspectionMediaType,
+                  caption: str(m.caption) || undefined,
+              }))
+            : []
+        const value = o.measure_value ?? o.value
+        return makeInspectionPoint({
+            id: str(o.id) || undefined,
+            section: str(o.section),
+            name: str(o.name),
+            kind: kind === 'tread' || kind === 'measure' ? kind : 'check',
+            status: status in RANK ? status : 'pending',
+            value: value == null || value === '' ? null : toAmount(value),
+            unit: str(o.unit) || undefined,
+            notes: str(o.notes),
+            recommendation: str(o.recommendation),
+            quantity: o.quantity == null ? 1 : toAmount(o.quantity),
+            unit_price: toAmount(o.unit_price),
+            media,
+            approval: ['none', 'pending', 'approved', 'declined'].includes(str(o.approval))
+                ? (str(o.approval) as InspectionPoint['approval'])
+                : undefined,
+        })
+    })
+}
+
+/**
+ * Recomendación → renglón del presupuesto: cada punto con recomendación se
+ * vuelve un renglón `item` (descripción «Punto — recomendación»). Se puede
+ * filtrar por respuesta del cliente (p. ej. solo las aprobadas).
+ */
+export function recommendationsToLines(
+    points: InspectionPoint[],
+    opts: { approval?: InspectionPoint['approval'][] } = {},
+): LineItem[] {
+    return points
+        .filter((p) => hasRecommendation(p) && (!opts.approval || (p.approval != null && opts.approval.includes(p.approval))))
+        .map((p) =>
+            makeLine({
+                description: `${p.name} — ${p.recommendation.trim()}`,
+                quantity: p.quantity > 0 ? p.quantity : 1,
+                unit_price: p.unit_price,
+            }),
+        )
+}

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

@@ -104,4 +104,20 @@ describe('DocumentPage', () => {
         await waitFor(() => expect(open).toHaveBeenCalledWith('https://x/y.pdf', '_blank', 'noopener,noreferrer'))
         expect(onAction).not.toHaveBeenCalled()
     })
+
+    it('el contador usa meta.total del servidor, no el tamaño de la página traída', async () => {
+        const api = {
+            get: vi.fn().mockResolvedValue({
+                data: { success: true, data: [{ id: 'r1', fiscal_uuid: 'REP-UUID-1' }], meta: { total: 312 } },
+            }),
+        } as unknown as ApiClient
+        render(
+            <ApiProvider client={api}>
+                <DocumentPage registration={registration} record={{ id: 'i1', number: 'A-42', total: 1500 }} onAction={vi.fn()} currency='MXN' />
+            </ApiProvider>,
+        )
+        // 312 en el botón inteligente y en la pestaña; nunca «1» (una fila traída).
+        await waitFor(() => expect(screen.getAllByText('312').length).toBeGreaterThan(0))
+        expect(screen.queryAllByText('1')).toHaveLength(0)
+    })
 })

package/src/document/document-page.tsx

@@ -60,12 +60,12 @@ export function DocumentPage(props: DocumentPageProps) {
     const fmt: FieldFormatOptions = { locale: props.locale, currency: props.currency, timeZone: props.timeZone }
 
     const recordId = record.id as string | number | undefined
-    const { sources, reload } = useDocumentSources(spec.sources, recordId)
+    const { sources, totals, reload } = useDocumentSources(spec.sources, recordId)
 
     const ctx: DocumentContext = useMemo(() => {
-        const base = { record, sources }
+        const base = { record, sources, totals }
         return { ...base, derived: registration.derive?.(base) ?? {} }
-    }, [record, sources, registration])
+    }, [record, sources, totals, registration])
 
     // Recarga las fuentes cuando el host avisa de un cambio (acción ejecutada).
     const [lastReload, setLastReload] = useState(props.reloadKey ?? 0)
@@ -120,7 +120,7 @@ export function DocumentPage(props: DocumentPageProps) {
 
     const smart: SmartButtonItem[] = (spec.smartButtons ?? [])
         .map((b): SmartButtonItem | null => {
-            const count = b.source ? sources[b.source]?.length ?? 0 : undefined
+            const count = b.source ? sourceCount(ctx, b.source) : undefined
             const active = b.source ? (count ?? 0) > 0 : b.field ? !!readPath(ctx, b.field) : true
             if (b.hideWhenEmpty && !active) return null
             const href = b.href ? interpolate(b.href, ctx) : undefined
@@ -179,8 +179,13 @@ export function DocumentPage(props: DocumentPageProps) {
     )
 }
 
+/** Total de una fuente: el del servidor si lo dio (`meta.total`), si no las filas traídas. */
+function sourceCount(ctx: DocumentContext, key: string): number {
+    return ctx.totals?.[key] ?? ctx.sources[key]?.length ?? 0
+}
+
 function tabCount(tb: DocumentTabDef, ctx: DocumentContext): number | undefined {
-    if (tb.kind === 'records') return ctx.sources[tb.source]?.length
+    if (tb.kind === 'records') return ctx.sources[tb.source] ? sourceCount(ctx, tb.source) : undefined
     if (tb.kind === 'slot' && tb.count) {
         const v = readPath(ctx, tb.count)
         return typeof v === 'number' ? v : undefined

package/src/document/types.ts

@@ -183,6 +183,8 @@ export interface DocumentContext {
     record: Record<string, unknown>
     /** Filas por fuente (`sources[key]`). */
     sources: Record<string, Record<string, unknown>[]>
+    /** Total del servidor por fuente (`meta.total`); si falta, el contador usa el largo de `sources[key]`. */
+    totals?: Record<string, number>
     /** Derivados (`$`). */
     derived: Record<string, unknown>
 }

package/src/document/use-document-sources.ts

@@ -11,6 +11,12 @@ type Rows = Record<string, unknown>[]
 
 export interface DocumentSourcesState {
     sources: Record<string, Record<string, unknown>[]>
+    /**
+     * Total del servidor por fuente directa (`meta.total`), para que un contador
+     * diga 312 y no «50» (el tamaño de la página que se trajo). Una fuente sin
+     * `meta.total` —o de dos saltos— no aparece: el contador cae al largo de sus filas.
+     */
+    totals: Record<string, number>
     loading: boolean
     /** Vuelve a pedir todas las fuentes (tras ejecutar una acción). */
     reload: () => void
@@ -27,6 +33,7 @@ export function useDocumentSources(
 ): DocumentSourcesState {
     const api = useApi()
     const [sources, setSources] = useState<Record<string, Record<string, unknown>[]>>({})
+    const [totals, setTotals] = useState<Record<string, number>>({})
     const [loading, setLoading] = useState(false)
     const [nonce, setNonce] = useState(0)
     const reload = useCallback(() => setNonce((n) => n + 1), [])
@@ -34,10 +41,12 @@ export function useDocumentSources(
     useEffect(() => {
         if (!defs || defs.length === 0 || recordId === undefined || recordId === null) {
             setSources({})
+            setTotals({})
             return
         }
         let cancelled = false
         setLoading(true)
+        const seenTotals: Record<string, number> = {}
         const fetchRows = async (d: DocumentSourceDef, params: Record<string, string>): Promise<Rows> => {
             try {
                 const res = await api.get(`/data/${d.model}`, {
@@ -45,6 +54,9 @@ export function useDocumentSources(
                 })
                 const body = res.data
                 const rows = (body?.data ?? body) as unknown
+                const total = body?.meta?.total
+                // Sólo las consultas directas (sin `via`): las de dos saltos se parten en trozos y no suman.
+                if (!d.via && typeof total === 'number' && Number.isFinite(total)) seenTotals[d.key] = total
                 return Array.isArray(rows) ? (rows as Rows) : []
             } catch {
                 return []
@@ -80,6 +92,7 @@ export function useDocumentSources(
             .then((out) => {
                 if (cancelled) return
                 setSources(out)
+                setTotals(seenTotals)
                 setLoading(false)
             })
         return () => {
@@ -87,5 +100,5 @@ export function useDocumentSources(
         }
     }, [api, defs, recordId, nonce])
 
-    return { sources, loading, reload }
+    return { sources, totals, loading, reload }
 }