@asteby/metacore-runtime-react 46.1.0 → 46.2.1

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/calendar-date.ts

@@ -14,3 +14,15 @@ export function parseCalendarDate(v: unknown): Date | undefined {
     const d = new Date(s)
     return isNaN(d.getTime()) ? undefined : d
 }
+
+/**
+ * True when a serialized value is a pure CALENDAR DAY: `YYYY-MM-DD`, or that day at
+ * exactly UTC midnight (how the backend serves a `date` column). Anything with a
+ * real time of day is an INSTANT: a `timestamptz` shown with a day-only renderer
+ * must be read in the organization's zone, or an evening invoice (29 Sep 19:41 in
+ * Mexico City = 30 Sep 00:41Z) shows as the 30th (PIT-025).
+ */
+export function isCalendarDayValue(v: unknown): boolean {
+    if (typeof v !== 'string') return false
+    return /^\d{4}-\d{2}-\d{2}(?:[T ]00:00:00(?:\.0+)?(?:Z|\+00:00)?)?$/.test(v.trim())
+}

package/src/dynamic-columns.tsx

@@ -15,7 +15,7 @@
 import * as React from 'react'
 import { ColumnDef } from '@tanstack/react-table'
 import { format, type Locale } from 'date-fns'
-import { parseCalendarDate } from './calendar-date'
+import { isCalendarDayValue, parseCalendarDate } from './calendar-date'
 import { es, enUS } from 'date-fns/locale'
 import { Calendar, Check, Copy, Mail, Minus, MoreHorizontal } from 'lucide-react'
 import {
@@ -525,10 +525,13 @@ export function formatDateCell(
                 }).format(date),
             }
         }
-        // Pure calendar date: pin to UTC so it never shifts across zones.
+        // Pure calendar date: pin to UTC so it never shifts across zones. A value
+        // with a real time of day is an instant even under a day-only renderer
+        // (timestamptz columns like invoice_date): show ITS day in the org zone.
+        const calendarDay = typeof value !== 'string' || isCalendarDayValue(value)
         return {
             display: new Intl.DateTimeFormat(localeTag, {
-                timeZone: 'UTC',
+                timeZone: calendarDay ? 'UTC' : timeZone,
                 dateStyle: 'long',
             }).format(date),
         }