@asteby/metacore-runtime-react 45.0.0 → 45.3.0

package/src/business/product-search.ts

@@ -0,0 +1,108 @@
+// Búsqueda unificada de producto (productos, llantas y variantes).
+// Un solo cuadro acepta: medida de llanta «205/55R16», código de barras (EAN/UPC
+// numérico), SKU/clave de proveedor o texto libre. `parseProductQuery` clasifica
+// la entrada para que el backend/addon elija el índice correcto.
+import type { LineItem } from './line-items'
+import { makeLine } from './line-items'
+
+export interface TireSize {
+    width: number
+    ratio: number
+    rim: number
+    /** Forma canónica `205/55R16`. */
+    normalized: string
+}
+
+export type ProductQuery =
+    | { kind: 'empty'; raw: string }
+    | { kind: 'barcode'; raw: string; barcode: string }
+    | { kind: 'tire_size'; raw: string; tire: TireSize }
+    | { kind: 'text'; raw: string; text: string }
+
+// 205/55R16, 205 55 16, 205-55-16, 205/55ZR16, 2055516 (sin separadores).
+const TIRE_RE = /^(\d{3})\s*[\/\-x\s]?\s*(\d{2})\s*[\/\-x\s]?\s*(?:z?r|-)?\s*(\d{2})$/i
+const BARCODE_RE = /^\d{8,14}$/
+
+export function parseTireSize(input: string): TireSize | null {
+    const s = input.trim()
+    // 7 dígitos pegados también son medida, pero 8+ dígitos es código de barras.
+    if (BARCODE_RE.test(s)) return null
+    const m = TIRE_RE.exec(s)
+    if (!m) return null
+    const width = Number(m[1])
+    const ratio = Number(m[2])
+    const rim = Number(m[3])
+    if (width < 125 || width > 395 || ratio < 25 || ratio > 95 || rim < 10 || rim > 26) return null
+    return { width, ratio, rim, normalized: `${width}/${ratio}R${rim}` }
+}
+
+export function parseProductQuery(raw: string): ProductQuery {
+    const s = raw.trim()
+    if (!s) return { kind: 'empty', raw }
+    if (BARCODE_RE.test(s)) return { kind: 'barcode', raw, barcode: s }
+    const tire = parseTireSize(s)
+    if (tire) return { kind: 'tire_size', raw, tire }
+    return { kind: 'text', raw, text: s }
+}
+
+export interface StockByWarehouse {
+    warehouse_id: string
+    warehouse_name?: string
+    available: number
+}
+
+export interface ProductVariant {
+    id: string
+    /** «Rin 16 · 205/55R16 · 91V». */
+    label: string
+    sku?: string
+    barcode?: string
+    price?: number
+    stock?: StockByWarehouse[]
+}
+
+export interface ProductResult {
+    id: string
+    name: string
+    sku?: string
+    barcode?: string
+    /** Clave del proveedor (búsqueda por SKU del proveedor). */
+    supplier_sku?: string
+    kind?: 'product' | 'tire' | 'service' | 'bundle'
+    price?: number
+    tax_rate?: number
+    tire?: TireSize
+    variants?: ProductVariant[]
+    stock?: StockByWarehouse[]
+    /** Paquetes automáticos: ids/nombres que se sugieren junto al producto. */
+    bundle_items?: Array<{ product_id: string; name: string; quantity: number }>
+}
+
+/** Existencia disponible: de la variante o del producto, en un almacén o en total. */
+export function availableStock(
+    source: { stock?: StockByWarehouse[] },
+    warehouseId?: string,
+): number | undefined {
+    if (!source.stock) return undefined
+    return source.stock
+        .filter((s) => !warehouseId || s.warehouse_id === warehouseId)
+        .reduce((n, s) => n + s.available, 0)
+}
+
+/** Producto (+ variante) → renglón listo para <LineItemsEditor>. */
+export function productToLine(
+    p: ProductResult,
+    variant?: ProductVariant,
+    opts: { warehouseId?: string; quantity?: number } = {},
+): LineItem {
+    const src = variant ?? p
+    return makeLine({
+        product_id: variant?.id ?? p.id,
+        sku: variant?.sku ?? p.sku,
+        description: variant ? `${p.name} · ${variant.label}` : p.name,
+        quantity: opts.quantity ?? 1,
+        unit_price: variant?.price ?? p.price ?? 0,
+        tax_rate: p.tax_rate ?? 0,
+        available: availableStock(src, opts.warehouseId) ?? availableStock(p, opts.warehouseId),
+    })
+}

package/src/business/refund-destination.tsx

@@ -0,0 +1,121 @@
+// RefundDestination — a dónde regresa el dinero: efectivo, tarjeta, monedero,
+// saldo a favor o NC CFDI (benchmark §7, POS-3/DEV-*).
+import { useMemo } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Button, Input } from '@asteby/metacore-ui'
+import { useFormatter, roundMoney } from './format'
+import {
+    DEFAULT_REFUND_DESTINATIONS,
+    singleDestination,
+    validateRefund,
+    type RefundAllocation,
+    type RefundDestinationKind,
+    type RefundDestinationOption,
+    type RefundValidation,
+} from './refund'
+
+export interface RefundDestinationProps {
+    /** Monto total a reembolsar. */
+    total: number
+    value: RefundAllocation[]
+    onChange: (allocations: RefundAllocation[]) => void
+    /** Destinos ofrecidos (default: los cinco). Filtra/limita según el documento. */
+    options?: RefundDestinationOption[]
+    /** Emite la validación tras cada cambio (para bloquear «Confirmar»). */
+    onValidate?: (v: RefundValidation) => void
+    /** Errores del servidor `"<índice>.<campo>"`. */
+    serverErrors?: Record<string, string>
+    /** Permite repartir entre varios destinos. Default false (un solo destino). */
+    allowSplit?: boolean
+    currency?: string
+    disabled?: boolean
+}
+
+export function RefundDestination({
+    total,
+    value,
+    onChange,
+    options = DEFAULT_REFUND_DESTINATIONS,
+    onValidate,
+    serverErrors,
+    allowSplit = false,
+    currency,
+    disabled,
+}: RefundDestinationProps) {
+    const { t } = useTranslation()
+    const fmt = useFormatter({ currency })
+    const validation = useMemo(() => validateRefund(total, value, options), [total, value, options])
+    const errors = { ...validation.errors, ...serverErrors }
+    const chosen = (k: RefundDestinationKind) => value.some((a) => a.kind === k)
+
+    const emit = (next: RefundAllocation[]) => {
+        onChange(next)
+        onValidate?.(validateRefund(total, next, options))
+    }
+    const toggle = (o: RefundDestinationOption) => {
+        if (!allowSplit) return emit(singleDestination(o.kind, total))
+        if (chosen(o.kind)) return emit(value.filter((a) => a.kind !== o.kind))
+        emit([...value, { kind: o.kind, amount: Math.max(0, roundMoney(total - validation.allocated)) }])
+    }
+
+    return (
+        <div data-slot="refund-destination" className="space-y-2">
+            <p className="text-sm text-muted-foreground">
+                {t('refund.amount', { defaultValue: 'Monto a reembolsar' })}: <span className="font-semibold text-foreground">{fmt.money(total)}</span>
+            </p>
+            <div role={allowSplit ? 'group' : 'radiogroup'} className="grid gap-2 sm:grid-cols-2">
+                {options.map((o) => {
+                    const off = o.available === false
+                    const on = chosen(o.kind)
+                    return (
+                        <Button
+                            key={o.kind}
+                            type="button"
+                            variant={on ? 'default' : 'outline'}
+                            role={allowSplit ? 'checkbox' : 'radio'}
+                            aria-checked={on}
+                            disabled={disabled || off}
+                            title={off ? o.disabledReason : undefined}
+                            className="h-auto justify-start whitespace-normal py-2 text-left"
+                            onClick={() => toggle(o)}
+                        >
+                            <span>
+                                <span className="block">{o.label}</span>
+                                {off && o.disabledReason && <span className="block text-xs opacity-70">{o.disabledReason}</span>}
+                                {!off && o.maxAmount != null && <span className="block text-xs opacity-70">{t('refund.max', { defaultValue: 'Máx.' })} {fmt.money(o.maxAmount)}</span>}
+                            </span>
+                        </Button>
+                    )
+                })}
+            </div>
+
+            {value.map((a, i) => (
+                <div key={a.kind} className="grid grid-cols-[1fr_8rem_10rem] items-start gap-2">
+                    <span className="pt-2 text-sm">{options.find((o) => o.kind === a.kind)?.label ?? a.kind}</span>
+                    <div>
+                        <Input
+                            inputMode="decimal"
+                            className="text-right"
+                            value={String(a.amount)}
+                            disabled={disabled || !allowSplit}
+                            aria-invalid={!!errors[`${i}.amount`]}
+                            onChange={(e) => emit(value.map((x, j) => (j === i ? { ...x, amount: Number(e.target.value.replace(',', '.')) || 0 } : x)))}
+                        />
+                        {errors[`${i}.amount`] && <p className="mt-0.5 text-xs text-destructive">{errors[`${i}.amount`]}</p>}
+                    </div>
+                    {(a.kind === 'card' || a.kind === 'transfer' || a.kind === 'credit_note') && (
+                        <Input
+                            placeholder={a.kind === 'card' || a.kind === 'transfer' ? t('refund.cardRef', { defaultValue: 'Referencia' }) : t('refund.ncRef', { defaultValue: 'Folio / UUID relacionado' })}
+                            value={a.reference ?? ''}
+                            disabled={disabled}
+                            onChange={(e) => emit(value.map((x, j) => (j === i ? { ...x, reference: e.target.value } : x)))}
+                        />
+                    )}
+                    {errors[`${i}.kind`] && <p className="col-span-3 text-xs text-destructive">{errors[`${i}.kind`]}</p>}
+                </div>
+            ))}
+
+            {validation.form && value.length > 0 && <p role="alert" className="text-sm text-destructive">{validation.form}</p>}
+        </div>
+    )
+}

package/src/business/refund.ts

@@ -0,0 +1,72 @@
+// Destino de un reembolso (ReturnWizard, cancelación de apartado, anticipos).
+// Lógica pura de <RefundDestination>.
+import { roundMoney, toAmount } from './format'
+
+export type RefundDestinationKind = 'cash' | 'card' | 'transfer' | 'wallet' | 'store_credit' | 'credit_note'
+
+export interface RefundDestinationOption {
+    kind: RefundDestinationKind
+    label: string
+    /** Tope reembolsable por este destino (p. ej. lo pagado con tarjeta). */
+    maxAmount?: number
+    /** false → la opción se muestra deshabilitada con `disabledReason`. */
+    available?: boolean
+    disabledReason?: string
+}
+
+export interface RefundAllocation {
+    kind: RefundDestinationKind
+    amount: number
+    /** Referencia del reembolso a tarjeta / folio de NC relacionada. */
+    reference?: string
+}
+
+/** Catálogo por defecto: el llamador filtra/limita según el documento. */
+export const DEFAULT_REFUND_DESTINATIONS: RefundDestinationOption[] = [
+    { kind: 'cash', label: 'Efectivo' },
+    { kind: 'card', label: 'Tarjeta' },
+    { kind: 'transfer', label: 'Transferencia' },
+    { kind: 'wallet', label: 'Monedero' },
+    { kind: 'store_credit', label: 'Saldo a favor' },
+    { kind: 'credit_note', label: 'Nota de crédito (CFDI)' },
+]
+
+export interface RefundValidation {
+    errors: Record<string, string>
+    form?: string
+    allocated: number
+    remaining: number
+    valid: boolean
+}
+
+export function validateRefund(
+    total: number,
+    allocations: RefundAllocation[],
+    options: RefundDestinationOption[] = DEFAULT_REFUND_DESTINATIONS,
+): RefundValidation {
+    const byKind = new Map(options.map((o) => [o.kind, o]))
+    const errors: Record<string, string> = {}
+    let allocated = 0
+    const seen = new Set<string>()
+    allocations.forEach((a, i) => {
+        const o = byKind.get(a.kind)
+        const amt = toAmount(a.amount)
+        allocated += amt
+        if (!o || o.available === false) errors[`${i}.kind`] = o?.disabledReason ?? 'Destino no disponible'
+        if (seen.has(a.kind)) errors[`${i}.kind`] = 'Ese destino ya está en la lista'
+        seen.add(a.kind)
+        if (amt <= 0) errors[`${i}.amount`] = 'Captura un monto mayor a cero'
+        else if (o?.maxAmount != null && amt > o.maxAmount) errors[`${i}.amount`] = `El máximo para ${o.label} es ${o.maxAmount}`
+    })
+    allocated = roundMoney(allocated)
+    const remaining = roundMoney(total - allocated)
+    let form: string | undefined
+    if (allocations.length === 0) form = 'Elige a dónde se devuelve el dinero'
+    else if (remaining !== 0) form = remaining > 0 ? 'Falta asignar parte del reembolso' : 'La suma excede el monto a reembolsar'
+    return { errors, form, allocated, remaining, valid: !form && Object.keys(errors).length === 0 }
+}
+
+/** Un solo destino cubriendo todo el monto (caso común). */
+export function singleDestination(kind: RefundDestinationKind, total: number): RefundAllocation[] {
+    return [{ kind, amount: roundMoney(total) }]
+}

package/src/business/return-wizard.tsx

@@ -0,0 +1,223 @@
+// ReturnWizard («Devolver mercancía») — un solo componente para POS, Pedido,
+// Factura, RMA y OT (benchmark §7, DEV-2). No conoce endpoints: recibe los
+// renglones devolvibles y entrega un payload por `onSubmit`.
+import { useMemo, useState } from 'react'
+import { useTranslation } from 'react-i18next'
+import { Button, Input } from '@asteby/metacore-ui'
+import { useFormatter } from './format'
+import { RefundDestination } from './refund-destination'
+import {
+    DEFAULT_REFUND_DESTINATIONS,
+    type RefundAllocation,
+    type RefundDestinationOption,
+} from './refund'
+import {
+    RETURN_CONDITION_DESTINATIONS,
+    computeReturnTotals,
+    creditNoteRelation,
+    defaultStockDestination,
+    returnSteps,
+    returnableQty,
+    serializeReturn,
+    validateReturnChoices,
+    validateReturnRefund,
+    type ReturnChoices,
+    type ReturnCondition,
+    type ReturnStep,
+    type ReturnStockDestination,
+    type ReturnSubmitPayload,
+    type ReturnableLine,
+} from './return'
+
+export interface ReturnWizardProps {
+    lines: ReturnableLine[]
+    /** ¿Hay un addon de almacén que confirma la recepción? Sin él, «Recibir» es un paso. */
+    warehouseConnected?: boolean
+    /** La venta está facturada: habilita la NC CFDI con relación 01/03 automática. */
+    invoiced?: boolean
+    /** Destinos de reembolso; `credit_note` se deshabilita solo si no está facturada. */
+    refundOptions?: RefundDestinationOption[]
+    reasons?: { value: string; label: string }[]
+    currency?: string
+    submitting?: boolean
+    /** Errores del servidor (`"<key>.<campo>"`). */
+    serverErrors?: Record<string, string>
+    onSubmit: (payload: ReturnSubmitPayload) => void | Promise<void>
+    onCancel?: () => void
+}
+
+const DEFAULT_REASONS = [
+    { value: 'not_wanted', label: 'No lo quiso' },
+    { value: 'defective', label: 'Defectuoso' },
+    { value: 'wrong_item', label: 'Producto equivocado' },
+    { value: 'warranty', label: 'Garantía' },
+]
+
+const STOCK_LABEL: Record<ReturnStockDestination, string> = { stock: 'Regresa a stock', scrap: 'Merma', warranty: 'Garantía con proveedor' }
+const STEP_LABEL: Record<ReturnStep, string> = { lines: 'Renglones', condition: 'Condición', receive: 'Recibir', refund: 'Reembolso' }
+
+export function ReturnWizard({
+    lines,
+    warehouseConnected = false,
+    invoiced = false,
+    refundOptions = DEFAULT_REFUND_DESTINATIONS,
+    reasons = DEFAULT_REASONS,
+    currency,
+    submitting,
+    serverErrors,
+    onSubmit,
+    onCancel,
+}: ReturnWizardProps) {
+    const { t } = useTranslation()
+    const fmt = useFormatter({ currency })
+    const steps = useMemo(() => returnSteps({ warehouseConnected }), [warehouseConnected])
+    const [stepIdx, setStepIdx] = useState(0)
+    const [choices, setChoices] = useState<ReturnChoices>({})
+    const [reason, setReason] = useState('')
+    const [notes, setNotes] = useState('')
+    const [received, setReceived] = useState(false)
+    const [refund, setRefund] = useState<RefundAllocation[]>([])
+
+    const step = steps[stepIdx]
+    const totals = useMemo(() => computeReturnTotals(lines, choices), [lines, choices])
+    const validation = useMemo(() => validateReturnChoices(lines, choices, reason), [lines, choices, reason])
+    const relation = useMemo(() => creditNoteRelation(lines, choices), [lines, choices])
+    const options = useMemo(
+        () =>
+            refundOptions.map((o) =>
+                o.kind === 'credit_note' && !invoiced
+                    ? { ...o, available: false, disabledReason: 'La venta no está facturada' }
+                    : o.kind === 'credit_note'
+                      ? { ...o, label: `${o.label} · relación ${relation}` }
+                      : o,
+            ),
+        [refundOptions, invoiced, relation],
+    )
+    const refundValidation = useMemo(() => validateReturnRefund(totals.total, refund, options), [totals.total, refund, options])
+    const errors = { ...validation.errors, ...serverErrors }
+
+    const setChoice = (key: string, patch: Partial<ReturnChoices[string]>) =>
+        setChoices((prev) => {
+            const cur = prev[key] ?? { quantity: 0, condition: 'sellable' as ReturnCondition, destination: 'stock' as ReturnStockDestination }
+            const next = { ...cur, ...patch }
+            if (patch.condition && !patch.destination) next.destination = defaultStockDestination(patch.condition)
+            return { ...prev, [key]: next }
+        })
+
+    const canNext =
+        step === 'lines' ? validation.valid
+        : step === 'condition' ? validation.valid
+        : step === 'receive' ? received
+        : refundValidation.valid
+
+    const submit = () =>
+        onSubmit(serializeReturn({ lines, choices, reason, notes, received: warehouseConnected ? false : received, refund }))
+
+    return (
+        <div data-slot="return-wizard" className="space-y-4">
+            <ol className="flex flex-wrap gap-2 text-xs">
+                {steps.map((s, i) => (
+                    <li key={s} aria-current={i === stepIdx ? 'step' : undefined} className={i === stepIdx ? 'font-semibold text-foreground' : 'text-muted-foreground'}>
+                        {i + 1}. {t(`returns.step.${s}`, { defaultValue: STEP_LABEL[s] })}
+                    </li>
+                ))}
+                {warehouseConnected && (
+                    <li className="text-muted-foreground">{t('returns.step.warehouse', { defaultValue: 'Almacén confirma la recepción' })}</li>
+                )}
+            </ol>
+
+            {(step === 'lines' || step === 'condition') && (
+                <div className="space-y-2">
+                    {lines.map((l) => {
+                        const c = choices[l.key]
+                        const max = returnableQty(l)
+                        return (
+                            <div key={l.key} className="grid gap-2 rounded-md border p-2 sm:grid-cols-[1fr_6rem_auto]">
+                                <div>
+                                    <p className="text-sm font-medium">{l.description}</p>
+                                    <p className="text-xs text-muted-foreground">
+                                        {t('returns.sold', { defaultValue: 'Vendido' })}: {l.sold} · {t('returns.returnable', { defaultValue: 'Por devolver' })}: {max} · {fmt.money(l.unit_price)}
+                                    </p>
+                                </div>
+                                {step === 'lines' ? (
+                                    <div>
+                                        <Input
+                                            inputMode="decimal"
+                                            className="text-right"
+                                            aria-label={l.description}
+                                            disabled={max === 0}
+                                            value={c ? String(c.quantity) : ''}
+                                            placeholder="0"
+                                            onChange={(e) => setChoice(l.key, { quantity: Number(e.target.value.replace(',', '.')) || 0 })}
+                                        />
+                                        {errors[`${l.key}.quantity`] && <p className="mt-0.5 text-xs text-destructive">{errors[`${l.key}.quantity`]}</p>}
+                                    </div>
+                                ) : (
+                                    (c?.quantity ?? 0) > 0 && (
+                                        <div className="sm:col-span-2 flex flex-wrap items-center gap-2">
+                                            {(['sellable', 'defective'] as ReturnCondition[]).map((cond) => (
+                                                <Button key={cond} type="button" size="sm" variant={c!.condition === cond ? 'default' : 'outline'} onClick={() => setChoice(l.key, { condition: cond })}>
+                                                    {cond === 'sellable' ? t('returns.sellable', { defaultValue: 'Vendible' }) : t('returns.defective', { defaultValue: 'Defectuoso' })}
+                                                </Button>
+                                            ))}
+                                            {RETURN_CONDITION_DESTINATIONS[c!.condition].length > 1 &&
+                                                RETURN_CONDITION_DESTINATIONS[c!.condition].map((d) => (
+                                                    <Button key={d} type="button" size="sm" variant={c!.destination === d ? 'secondary' : 'ghost'} onClick={() => setChoice(l.key, { destination: d })}>
+                                                        {STOCK_LABEL[d]}
+                                                    </Button>
+                                                ))}
+                                            {RETURN_CONDITION_DESTINATIONS[c!.condition].length === 1 && (
+                                                <span className="text-xs text-muted-foreground">{STOCK_LABEL[c!.destination]}</span>
+                                            )}
+                                            {errors[`${l.key}.destination`] && <p className="w-full text-xs text-destructive">{errors[`${l.key}.destination`]}</p>}
+                                        </div>
+                                    )
+                                )}
+                            </div>
+                        )
+                    })}
+                    {step === 'lines' && (
+                        <div className="grid gap-2 sm:grid-cols-2">
+                            <select className="h-9 rounded-md border bg-background px-2 text-sm" value={reason} onChange={(e) => setReason(e.target.value)} aria-label={t('returns.reason', { defaultValue: 'Motivo' })}>
+                                <option value="">{t('returns.reason', { defaultValue: 'Motivo' })}…</option>
+                                {reasons.map((r) => (
+                                    <option key={r.value} value={r.value}>{r.label}</option>
+                                ))}
+                            </select>
+                            <Input value={notes} onChange={(e) => setNotes(e.target.value)} placeholder={t('returns.notes', { defaultValue: 'Notas (opcional)' })} />
+                        </div>
+                    )}
+                    {validation.form && stepIdx === 0 && Object.keys(choices).length > 0 && <p role="alert" className="text-sm text-destructive">{validation.form}</p>}
+                </div>
+            )}
+
+            {step === 'receive' && (
+                <label className="flex items-start gap-2 rounded-md border p-3 text-sm">
+                    <input type="checkbox" className="mt-1" checked={received} onChange={(e) => setReceived(e.target.checked)} />
+                    <span>{t('returns.receiveHere', { defaultValue: 'Confirmo que la mercancía ya está en tienda. No hay almacén que la reciba, así que la recepción se registra aquí.' })}</span>
+                </label>
+            )}
+
+            {step === 'refund' && (
+                <RefundDestination total={totals.total} value={refund} onChange={setRefund} options={options} currency={currency} allowSplit serverErrors={serverErrors} />
+            )}
+
+            <div className="flex items-center justify-between gap-2 border-t pt-3">
+                <span className="text-sm">
+                    {t('returns.total', { defaultValue: 'Total a devolver' })}: <strong>{fmt.money(totals.total)}</strong>
+                </span>
+                <div className="flex gap-2">
+                    {onCancel && stepIdx === 0 && <Button type="button" variant="outline" onClick={onCancel}>{t('common.cancel', { defaultValue: 'Cancelar' })}</Button>}
+                    {stepIdx > 0 && <Button type="button" variant="outline" onClick={() => setStepIdx(stepIdx - 1)}>{t('common.back', { defaultValue: 'Atrás' })}</Button>}
+                    {stepIdx < steps.length - 1 ? (
+                        <Button type="button" disabled={!canNext} onClick={() => setStepIdx(stepIdx + 1)}>{t('common.next', { defaultValue: 'Siguiente' })}</Button>
+                    ) : (
+                        <Button type="button" disabled={!canNext || submitting} onClick={submit}>
+                            {t('returns.confirm', { defaultValue: 'Confirmar devolución' })} {fmt.money(totals.total)}
+                        </Button>
+                    )}
+                </div>
+            </div>
+        </div>
+    )
+}