// ─── Compras · Detalle de Ítem de Compra ──────────────────────────────────
// ComprasDetailScreen: documento editable in-place sobre el motor DocumentShell/
// DocCard/ItemsTable (doc-kit). Extraído de screens-others.jsx (P9, split del
// cajón de 5 módulos). Expone a window: ComprasDetailScreen. Consume
// makeCompraDetail/makeBlankCompra (detalle-helpers.js), DocumentShell/DocCard/
// ItemsTable/Totals/useDocEdit/buildDocActions/ConfirmDeleteModal/FileUploadCard/
// ObservacionesCard (ui/doc-kit-*.jsx), MicosMetaCell (ui/doc-kit-meta.jsx),
// PartySelectorModal (screens-nuevo.jsx), ExpedienteCombobox/expedienteLabelFromId/
// useExpedienteSeed/resolveExpedienteIdForSave/expedienteMetaField (combobox.jsx),
// COMPRA_ESTADOS (dominio/pipeline.js), MicosAdjuntos (dominio/adjuntos.js) y
// MicosStore (persistencia del comprobante).
//
// DECISIÓN 3 — la compra lleva su info + FOTO/PDF DEL COMPROBANTE (adjunto real, opcional,
// misma infra de la DECISIÓN 9). MURIÓ la vinculación de pagos: se quitó PagosVinculadosCard
// y sus botones "Asociar comprobante de pago" / "Desvincular pago" (eran no-ops).
//
// P9 — write-path real: `expedienteId` es un uuid real (FK compras.expediente_id,
// P2) — el draft de edición sigue mostrando/tipeando el publicId (EXP-…) vía
// ExpedienteCombobox (cero cambio visible), pero al entrar a editar se siembra
// resolviendo el uuid guardado a su publicId, y al guardar se resuelve el texto
// tipeado/elegido DE VUELTA al uuid real. Nunca un texto suelto en una columna
// uuid (el bug original: 400 "invalid input syntax for type uuid").
//
// Fix de raíz (review rechazada, mismo día): la resolución era un `find` sobre
// window.EXPEDIENTES, que solo hidrata ~500 de ~2100 reales (BIG_LIMIT) — un
// expediente_id real fuera de esa ventana (a) al tipear su publicId de alta
// guardaba null con toast de éxito, y (b, DESTRUCTIVO) al editar sin tocar el
// campo, el draft se sembraba con '' y guardar pisaba en silencio un FK válido
// con null. useExpedienteSeed/resolveExpedienteIdForSave/expedienteMetaField
// (screens/compras/combobox.jsx) resuelven contra el backend (mismo endpoint que
// openExpedienteFor, core/router.jsx) antes de sembrar/guardar: nunca se cae a
// '' o null cuando el FK original existe, y un publicId inexistente (alta o
// edición) muestra error inline en vez de guardar null.

function ComprasDetailScreen({ compraId, isCreate = false, startEditing = false, onBack, onSaved, onDeleted }) {
  // En alta trabajamos sobre una compra en blanco (estable durante el montaje).
  const blank = React.useMemo(() => (isCreate ? makeBlankCompra() : null), [isCreate]);
  const original = isCreate ? blank : (COMPRAS.find((c) => c.id === compraId) || COMPRAS[0]);
  // `refreshTick` recomputa el detalle (y con él `archivos`) tras subir/borrar/renombrar un
  // adjunto del comprobante — DOCUMENTOS cambia pero `original` no, así que sin esto el memo
  // no se enteraría.
  const [refreshTick, setRefreshTick] = React.useState(0);
  const detail = React.useMemo(() => makeCompraDetail(original), [original.id, original, refreshTick]);
  const Math_ = window.MicosItemsMath;

  const [toast, setToast] = React.useState(null);
  const [provPicker, setProvPicker] = React.useState(false);
  const [confirmDel, setConfirmDel] = React.useState(false);
  const [expedienteError, setExpedienteError] = React.useState(null);
  const uploaderRef = React.useRef(null); // DECISIÓN 9: captura los adjuntos pendientes del comprobante

  const { editing, draft, setDraft, enterEdit, discardEdit, saveEdit, patch } = window.useDocEdit(
    () => ({
      proveedor: original.proveedor || '',
      proveedorId: original.proveedorId || null,
      fecha: original.fecha,
      estado: original.estado || 'PENDIENTE',
      // Uuid real → publicId visible (ver header). isCreate ya arranca en '' (sin expediente).
      expedienteId: expedienteLabelFromId(original.expedienteId, ''),
      comprobanteTipo: (original.comprobanteTipo && original.comprobanteTipo !== '—') ? original.comprobanteTipo : '',
      comprobanteNumero: (original.comprobanteNumero && original.comprobanteNumero !== '—') ? original.comprobanteNumero : '',
      fechaContable: detail.fechaContable,
      fechaVencimiento: detail.fechaVencimiento,
      descuentoPct: detail.descuentoPct,
      observaciones: detail.observaciones || '',
      items: detail.items.map((it) => Math_.migrate(it)),
    }),
    {
      startEditing: isCreate || startEditing,
      onCancel: () => { if (isCreate || startEditing) onBack && onBack(); },
      onSave: async (d) => {
        const items = (d.items || []).map((it) => {
          const cant = Number(it.cantidad) || 0, unit = Number(it.unitario) || 0, bonif = Number(it.bonifPct) || 0;
          return {
            sku: it.sku || '', descripcion: it.descripcion || '',
            cantidad: cant, unitario: unit, bonifPct: bonif,
            ivaPct: it.ivaPct == null ? 21 : Number(it.ivaPct),
            total: cant * unit * (1 - bonif / 100),
          };
        });
        // Totales (mismo cálculo que la vista de lectura).
        const subtotalRaw = items.reduce((s, i) => s + i.cantidad * i.unitario, 0);
        const descPct = Number(d.descuentoPct) || 0;
        const desc = subtotalRaw * (descPct / 100);
        const ivaTotal = items.reduce((s, i) => s + i.cantidad * i.unitario * (1 - i.bonifPct / 100) * ((i.ivaPct || 0) / 100), 0);
        // FIX hallazgo #15 (AUDITORIA-ui-decorativa-05-07-2026.md — "el descuento SÍ queda
        // horneado en total al guardar → al reeditar sin re-tipearlo, el recálculo puede pisar
        // el total con uno errado"): sin ítems reales (las 577 compras históricas sin detalle
        // migrado), `items` acá queda `[]` y el cálculo de arriba SIEMPRE daba $0 — reeditar
        // una de esas compras para tocar solo la fecha/el descuento/las observaciones pisaba en
        // silencio el total real de cabecera con 0. Misma regla que ya usa la vista de LECTURA
        // (más abajo, `totalCalc` del render): sin ítems, el total de cabecera (`original.total`)
        // es la única fuente de verdad — nunca se recalcula a partir de una lista vacía.
        const totalCalc = items.length ? Math.round(subtotalRaw - desc + ivaTotal) : (Number(original.total) || 0);
        // Resolver el texto del combobox (publicId tipeado/elegido) al uuid real —
        // honesto contra la ventana hidratada + backend (fix de raíz, ver header):
        // nunca null en silencio cuando el original tenía un expediente real, y un
        // publicId que no existe aborta el guardado con error inline en el campo.
        const expResolved = await resolveExpedienteIdForSave(d.expedienteId, expSeed.seedLabel, original.expedienteId);
        if (expResolved.notFoundText) {
          setExpedienteError(`No existe el expediente ${expResolved.notFoundText}`);
          return false;
        }
        const docObj = {
          ...original,
          proveedor: d.proveedor,
          proveedorId: d.proveedorId || null,
          fecha: d.fecha,
          estado: d.estado,
          expedienteId: expResolved.id,
          comprobanteTipo: d.comprobanteTipo || '—',
          comprobanteNumero: (d.comprobanteNumero || '').trim() || '—',
          fechaContable: d.fechaContable,
          fechaVencimiento: d.fechaVencimiento,
          descuentoPct: descPct,
          observaciones: (d.observaciones || '').trim(),
          itemsDetalle: items,
          items: items.length,
          total: totalCalc,
        };
        // DECISIÓN 9/3 — comprobante del proveedor: los adjuntos de sesión suben al bucket +
        // `documentos` (tipo COMPROBANTE_COMPRA) al GUARDAR la compra. En alta el uuid real
        // llega recién con la reconciliación del store (id-race), así que se suben en
        // `onReconciled`; en edición se suben en el acto (y si fallan, aborta el guardado).
        const pend = uploaderRef.current ? uploaderRef.current.getPending() : [];
        if (isCreate) {
          window.MicosStore.create('compras', { ...docObj, __nuevo: true }, async (rec) => {
            if (pend.length && window.MicosAdjuntos && rec && rec.id) {
              try { await window.MicosAdjuntos.subir(pend, { tipo: 'COMPROBANTE_COMPRA', compraId: rec.id }); }
              catch (e) { console.warn('[compras] subir comprobante (alta)', e); }
            }
          });
          if (uploaderRef.current) uploaderRef.current.clearPending();
          onSaved && onSaved(docObj.id);
        } else {
          window.MicosStore.update('compras', original.id, docObj);
          if (pend.length && window.MicosAdjuntos) {
            try {
              await window.MicosAdjuntos.subir(pend, { tipo: 'COMPROBANTE_COMPRA', compraId: original.id });
              uploaderRef.current.clearPending();
              setRefreshTick((t) => t + 1);
            } catch (err) {
              setToast('No se pudo subir el comprobante: ' + ((err && err.message) || 'error'));
              setTimeout(() => setToast(null), 5000);
              return false;
            }
          }
          setToast(`Compra ${docObj.numero} guardada`);
          setTimeout(() => setToast(null), 3600);
        }
      },
    }
  );
  const expSeed = useExpedienteSeed(original.expedienteId, editing, patch);
  React.useEffect(() => { if (!editing) setExpedienteError(null); }, [editing]);

  // Borrar/renombrar un adjunto YA persistido del comprobante reusa MicosStore
  // (soft-delete / PATCH del metadato) — misma infra que doc. médica/extra.
  const borrarAdjunto = (idx) => {
    const f = detail.archivos[idx];
    if (f && f.id && window.MicosStore) { window.MicosStore.remove('documentos', f.id); setRefreshTick((t) => t + 1); }
  };
  const renombrarAdjunto = (idx, nombre) => {
    const f = detail.archivos[idx];
    if (f && f.id && window.MicosStore) { window.MicosStore.update('documentos', f.id, { nombre }); setRefreshTick((t) => t + 1); }
  };

  // ── Extracción con IA del comprobante (mismo extractor/patrón que
  // finanzas/factura-recibida.jsx — acá SÍ se aplica al draft; antes la prop
  // `extractable` quedaba sin `extractor`/`onExtracted`, disparaba DeepSeek de
  // verdad y tiraba el resultado, gasto silencioso de API). Fuera de edición,
  // entra a editar antes de aplicar (mismo patrón que factura-recibida.jsx).
  const pendingExtract = React.useRef(null);
  const mergeExtract = (data) => setDraft((d) => {
    const next = { ...d };
    if (data.tipoFactura) next.comprobanteTipo = `Factura ${data.tipoFactura}`;
    if (data.numero) next.comprobanteNumero = `${String(data.puntoVenta || 1).padStart(5, '0')}-${String(data.numero).padStart(8, '0')}`;
    if (data.fechaEmision) next.fecha = data.fechaEmision;
    if (data.fechaVencPago) next.fechaVencimiento = data.fechaVencPago;
    if (data.observaciones) next.observaciones = data.observaciones;
    if (Array.isArray(data.items) && data.items.length) next.items = data.items.map((it) => Math_.migrate(it));
    return next;
  });
  const applyExtracted = (data) => {
    if (editing) mergeExtract(data);
    else { pendingExtract.current = data; enterEdit(); }
  };
  React.useEffect(() => {
    if (editing && draft && pendingExtract.current) {
      const d = pendingExtract.current; pendingExtract.current = null;
      mergeExtract(d);
    }
  }, [editing, draft]);

  // ── Ítems (edición) ──
  const patchItem = (idx, field, value) => setDraft((d) => {
    const items = d.items.map((it, i) => {
      if (i !== idx) return it;
      const next = { ...it, [field]: value };
      const cant = Number(next.cantidad) || 0, unit = Number(next.unitario) || 0, bonif = Number(next.bonifPct) || 0;
      next.total = cant * unit * (1 - bonif / 100);
      return next;
    });
    return { ...d, items };
  });
  const addItem = () => setDraft((d) => ({ ...d, items: [...d.items, Math_.blank()] }));
  const removeItem = (idx) => setDraft((d) => ({ ...d, items: d.items.filter((_, i) => i !== idx) }));

  // ── Valores a mostrar (draft en edición, original/detail en lectura) ──
  const itemsCalc = editing && draft ? draft.items : detail.items;
  const descPct = Number(editing && draft ? draft.descuentoPct : detail.descuentoPct) || 0;
  const subtotalRaw = itemsCalc.reduce((s, i) => s + (Number(i.cantidad) || 0) * (Number(i.unitario) || 0), 0);
  const descuento = subtotalRaw * (descPct / 100);
  const netoGravado = subtotalRaw - descuento;
  const ivaByRate = {};
  itemsCalc.forEach((i) => {
    const c = Number(i.cantidad) || 0, u = Number(i.unitario) || 0, b = Number(i.bonifPct) || 0, ivaPct = Number(i.ivaPct ?? 21);
    const base = c * u * (1 - b / 100);
    ivaByRate[ivaPct] = (ivaByRate[ivaPct] || 0) + base * (ivaPct / 100);
  });
  const ivaLines = Object.entries(ivaByRate)
    .sort(([a], [b]) => Number(a) - Number(b))
    .map(([rate, monto]) => ({ label: `IVA ${rate}%`, monto }));
  // Sin ítems reales (compra_item vacía — no migrada línea a línea, ver
  // makeCompraDetail), el total NO se recalcula en $0: usa el total de cabecera
  // real (original.total), que siempre viene de la DB (BUGS-caza-01-07-2026.md
  // #5/A5). Con al menos 1 ítem real (o cargado en edición), se calcula como
  // siempre desde los ítems.
  const totalCalc = itemsCalc.length
    ? netoGravado + ivaLines.reduce((s, l) => s + l.monto, 0)
    : (Number(original.total) || 0);

  const statusInfo = COMPRA_ESTADOS[editing && draft ? draft.estado : original.estado] || COMPRA_ESTADOS.PENDIENTE;
  const isPending = editing && draft ? !draft.comprobanteTipo : original.comprobanteTipo === '—';

  // Proveedor mostrado + sus datos fiscales (resueltos del directorio).
  const provName = editing && draft ? draft.proveedor : original.proveedor;
  const provId = editing && draft ? draft.proveedorId : original.proveedorId;
  const provRec = (window.PROVEEDORES || []).find((p) => p.id === provId);
  const provSub = provRec
    ? [provRec.condicionIva, provRec.cuit ? `CUIT ${provRec.cuit}` : null, provRec.condicionVenta].filter(Boolean)
    : null;

  const expedienteShown = editing && draft ? draft.expedienteId : expedienteLabelFromId(original.expedienteId, '');
  const actions = window.buildDocActions({
    editing, enterEdit, discardEdit, saveEdit,
    onDelete: (!isCreate && editing) ? () => setConfirmDel(true) : undefined,
  });

  const metaFields = [
    { label: 'Orden de Compra', value: original.numero, mono: true, accent: true },
    expedienteMetaField({
      editing, expSeed, patch,
      draftValue: draft && draft.expedienteId,
      shownValue: expedienteShown,
      error: expedienteError,
      onClearError: () => setExpedienteError(null),
    }),
    { label: 'Estado', editable: editing, input: 'select',
      options: Object.entries(COMPRA_ESTADOS).map(([v, c]) => ({ value: v, label: c.label })),
      value: editing ? draft.estado : statusInfo.label, onChange: (v) => patch('estado', v) },
    { label: 'Fecha emisión', editable: editing, input: 'date', mono: true,
      value: editing ? draft.fecha : formatDate(original.fecha), onChange: (v) => patch('fecha', v) },
    { label: 'Comprobante', editable: editing, input: 'select',
      options: [{ value: '', label: 'Sin comprobante' }, 'Factura A', 'Factura B', 'Factura C', 'Nota de crédito', 'Remito'],
      value: editing ? draft.comprobanteTipo : (isPending ? 'Pendiente' : original.comprobanteTipo),
      muted: !editing && isPending, onChange: (v) => patch('comprobanteTipo', v) },
    { label: 'Nº comprobante', editable: editing, input: 'text', mono: true,
      value: editing ? draft.comprobanteNumero : (isPending ? '—' : original.comprobanteNumero),
      placeholder: '0001-00000000', onChange: (v) => patch('comprobanteNumero', v) },
    { label: 'Fecha contable', editable: editing, input: 'date', mono: true,
      value: editing ? draft.fechaContable : formatDate(detail.fechaContable), onChange: (v) => patch('fechaContable', v) },
    { label: 'Vencimiento', editable: editing, input: 'date', mono: true,
      value: editing ? draft.fechaVencimiento : formatDate(detail.fechaVencimiento), onChange: (v) => patch('fechaVencimiento', v) },
    { label: 'Descuento (%)', editable: editing, input: 'number', mono: true,
      value: editing ? draft.descuentoPct
        : (detail.descuentoPct > 0 ? `${detail.descuentoPct}% · ${formatMoney(descuento)}` : 'Sin descuento'),
      muted: !editing && detail.descuentoPct === 0, onChange: (v) => patch('descuentoPct', v) },
  ];

  return (
    <DocumentShell
      onBack={onBack}
      backLabel="Volver a Compras"
      eyebrow="Compras · Detalle"
      statusLabel={statusInfo.label}
      statusPill="pill-oc"
      bigId={original.numero}
      expedienteId={expedienteShown}
      fechaEmision={editing && draft ? draft.fecha : original.fecha}
      editing={editing}
      isCreate={isCreate}
      toast={toast}
      subtitle={
        <>
          <span className="font-bold" style={{ color: 'var(--foreground)' }}>{provName || 'Sin proveedor'}</span>
          <span className="mx-1.5 opacity-50">·</span>
          {isPending ? <span style={{ fontStyle: 'italic' }}>Sin comprobante emitido</span> :
            <><span className="font-bold">{editing && draft ? draft.comprobanteTipo : original.comprobanteTipo}</span> <span className="font-mono">{editing && draft ? draft.comprobanteNumero : original.comprobanteNumero}</span></>
          }
          {expedienteShown ? <>
            <span className="mx-1.5 opacity-50">·</span>
            Expediente <span className="font-mono font-bold" style={{ color: 'var(--accent)' }}>{expedienteShown}</span>
          </> : null}
        </>
      }
      actions={actions}
    >
      {/* 1 · Foto / PDF del comprobante del proveedor (DECISIÓN 3 — adjunto real, opcional) */}
      <FileUploadCard
        eyebrow="Documentos adjuntos"
        title="Foto / PDF del comprobante"
        description="Subí la foto o el PDF del comprobante del proveedor (factura, remito o nota de crédito). Es opcional."
        files={detail.archivos}
        editing={editing}
        extractable
        realUpload
        extractor={window.MicosAIExtract && window.MicosAIExtract.facturaRecibida}
        onExtracted={applyExtracted}
        persistTarget={{ tipo: 'COMPROBANTE_COMPRA', compraId: original.id }}
        onUploaderReady={(api) => { uploaderRef.current = api; }}
        onRemove={borrarAdjunto}
        onRename={renombrarAdjunto}
      />

      {/* 2 · Datos de la compra (proveedor card + meta strip) */}
      {/* Proveedor + Datos del documento — card unificada */}
      <DocCard className="p-7 sm:p-8" editing={editing}>
        {/* Proveedor header */}
        <div className="flex items-start justify-between gap-4 flex-wrap mb-7">
          <div className="min-w-0">
            <p className="text-[11px] font-bold uppercase tracking-[0.2em] mb-2" style={{ color: 'var(--accent)' }}>
              Proveedor
            </p>
            <p className="text-[22px] font-extrabold tracking-tight leading-[1.1]"
              style={{ color: provName ? 'var(--foreground)' : 'color-mix(in oklab, var(--muted-foreground) 70%, transparent)' }}>
              {provName || 'Sin proveedor'}
            </p>
            <p className="text-[12.5px] mt-1.5" style={{ color: 'var(--muted-foreground)' }}>
              {provSub
                ? provSub.map((part, i) => (
                    <React.Fragment key={i}>
                      {i > 0 && <span className="mx-1.5 opacity-50">·</span>}
                      {part}
                    </React.Fragment>
                  ))
                : (editing ? 'Elegí un proveedor del directorio' : 'Sin datos del proveedor')}
            </p>
          </div>
          {editing && (
            <button className="btn btn-ghost" type="button" onClick={() => setProvPicker(true)}>
              <IconPencil size={13} />
              <span className="hidden sm:inline">{provName ? 'Cambiar proveedor' : 'Elegir proveedor'}</span>
            </button>
          )}
        </div>

        {/* Divider */}
        <div style={{ borderTop: '1px solid color-mix(in oklab, var(--border) 55%, transparent)', marginBottom: '1.75rem' }} />

        {/* Datos del documento */}
        <p className="text-[11px] font-bold uppercase tracking-[0.2em] mb-6" style={{ color: 'var(--accent)' }}>
          Datos del documento
        </p>
        <div className="grid grid-cols-2 sm:grid-cols-4 gap-x-8 gap-y-6">
          {metaFields.map((it, i) => <MicosMetaCell key={i} it={it} />)}
        </div>
      </DocCard>

      {/* 3 · Ítems */}
      <DocCard editing={editing}>
        <div className="flex items-center justify-between mb-5">
          <p className="text-[11px] font-bold uppercase tracking-[0.2em]" style={{ color: 'var(--accent)' }}>
            Ítems de la compra
          </p>
          {(editing || itemsCalc.length > 0) && (
            <p className="text-[11.5px] font-bold uppercase tracking-[0.1em]" style={{ color: 'var(--muted-foreground)' }}>
              {itemsCalc.length} {itemsCalc.length === 1 ? 'ítem' : 'ítems'}
            </p>
          )}
        </div>
        {!editing && itemsCalc.length === 0 ? (
          // Sin ítems reales migrados (compra_item vacía) — en vez de una tabla
          // vacía + "0 ítems / $0,00" (leído como "no se compró nada"), mostramos
          // el total real de cabecera con aviso explícito (BUGS-caza-01-07-2026.md
          // #5/A5: "no mostrar datos inventados/incompletos como si fueran reales").
          <div className="rounded-xl px-5 py-7 text-center" style={{
            border: '1px dashed color-mix(in oklab, var(--border) 70%, transparent)',
            background: 'color-mix(in oklab, var(--surface) 40%, transparent)',
          }}>
            <p className="text-[13px] font-bold" style={{ color: 'var(--foreground)' }}>
              Sin detalle de ítems migrado
            </p>
            <p className="text-[12px] mt-1.5 max-w-md mx-auto" style={{ color: 'var(--muted-foreground)' }}>
              Esta compra no tiene ítems línea a línea cargados en el sistema. El total es el de cabecera del comprobante.
            </p>
            <p className="text-[22px] font-extrabold tabular-nums mt-4" style={{ color: 'var(--accent)' }}>
              {formatMoney(totalCalc)}
            </p>
          </div>
        ) : (
          <>
            <ItemsTable
              items={itemsCalc}
              showBonif
              showIva
              editing={editing}
              onItemChange={patchItem}
              onItemRemove={removeItem}
              onAdd={addItem}
              // Procurement: el selector de inventario ofrece ítems SIN stock (es lo que se compra para reponer).
              mostrarSinStock
            />
            <Totals
              subtotal={netoGravado}
              bonificaciones={descuento}
              ivaLines={ivaLines}
              total={totalCalc}
            />
          </>
        )}
      </DocCard>

      {/* DECISIÓN 3 — la vinculación de pagos murió: se quitó la card "Comprobantes de pago
          propios" (botones "Asociar comprobante de pago" / "Desvincular pago" eliminados). El
          comprobante ahora vive como adjunto real arriba (sección 1). */}

      <ObservacionesCard
        editing={editing}
        value={editing && draft ? draft.observaciones : detail.observaciones}
        onChange={(v) => patch('observaciones', v)}
        placeholder="Notas sobre la compra, descuentos del proveedor, condiciones particulares…"
      />

      {/* Modales */}
      {provPicker && window.PartySelectorModal && (
        <window.PartySelectorModal
          type="proveedor"
          open={true}
          onClose={() => setProvPicker(false)}
          onPick={(obj) => {
            if (obj && obj.id) setDraft((d) => ({ ...d, proveedor: obj.razonSocial || obj.nombre || '', proveedorId: obj.id }));
            setProvPicker(false);
          }}
        />
      )}
      {confirmDel && window.ConfirmDeleteModal && (
        <window.ConfirmDeleteModal
          title="¿Eliminar orden de compra?"
          itemName={original.numero}
          description="Se moverá al archivo. Esta acción se puede revertir desde el visor de datos."
          onCancel={() => setConfirmDel(false)}
          onConfirm={() => {
            window.MicosStore.remove('compras', original.id);
            setConfirmDel(false);
            onDeleted && onDeleted();
          }}
        />
      )}
    </DocumentShell>
  );
}

Object.assign(window, { ComprasDetailScreen });