// ═══════════════════════════════════════════════════════════════
// inventory-lenses.jsx — the lens tools (Inventory Step 7)
// ═══════════════════════════════════════════════════════════════
//
// WHAT THIS IS (in plain English):
// Its own "Lenses" tab in the Stock Room, with the four things that only
// lenses need:
//
// Tomorrow's pull — the day before surgery, someone takes the lenses off
// the shelf. SurgSuite already set aside a specific lens for each eye when
// the worklist came in, so this is a checklist: scan each box as you pull
// it, and anything that doesn't belong gets flagged. Two boxes per eye is
// normal (the calculated lens plus a backup power), so a second box of the
// same lens is accepted quietly. When it's all covered you mark it
// verified and it locks, with your name and the time on it.
//
// Shelf audit — scan every lens on the shelf; get back what matched, what
// is on the shelf but unknown to the system, and what the system thinks it
// has but nobody scanned. Fixes are one click each (or all at once) and
// every one writes a proper stock line saying it came from the audit, so
// the history always explains itself.
//
// Returns — take a lens out of stock with a reason or tracking number,
// optionally tied to a patient and eye (that is how a STAAR backup going
// back gets recorded), and generate the vendor's own return form.
//
// Consigned lenses — the lenses a vendor sent for one named patient:
// which serial went in, which went back, which is still in the drawer.
// Nothing is stored: the status is read off the stock history.
// ═══════════════════════════════════════════════════════════════
const invTomorrow = () => {
const d = new Date(invToday() + 'T12:00:00');
d.setDate(d.getDate() + 1);
return d.toLocaleDateString('en-CA');
};
// Serial number → the lens it belongs to, for everything currently in stock.
// A lens box barcode carries the product code as well as the serial, but a
// serial typed in by hand (or read off the sticker) carries neither — and the
// system already knows which lens that serial came in as, so it should not
// have to be told.
function invSerialIndex(onHand) {
const m = new Map();
for (const [pid, bal] of Object.entries((onHand && onHand.products) || {})) {
for (const lot of bal.lots || []) if (lot.serial && lot.onHand > 0) m.set(invNorm(lot.serial), pid);
}
return m;
}
// ─── A scan box that records every scan, recognized or not ───────
// Anything the catalog knows comes back with its product; anything it does
// not is still recorded, because "on the shelf but unknown to the system" is
// exactly the finding an audit exists to make.
function InvLensScanBox({ products, onScan, placeholder, autoFocus, disabled, serialIndex }) {
const [q, setQ] = invUseState('');
const submit = () => {
const raw = q.trim();
if (!raw) return;
const found = invFindByScan(products, raw);
const scan = found.scan || {};
const serial = scan.serial || (scan.gtin && scan.gtin !== raw ? '' : raw);
let product = found.product;
if (!product && serial && serialIndex) {
const pid = serialIndex.get(invNorm(serial));
if (pid) product = products.find((p) => p.id === pid) || null;
}
onScan({
raw,
serial,
lot: scan.lot || '',
expiry: scan.expiry || '',
gtin: scan.gtin || '',
productId: product ? product.id : '',
description: product ? product.description : '',
});
setQ('');
};
return (
);
}
// ─── Tomorrow's lens pull ────────────────────────────────────────
function InvLensPull({ stores, savedOrConflict, toast, me, refreshAll, onHand }) {
const P = stores.products.data || [];
const PULLS = stores.lens_pulls.data || [];
const serialIndex = invUseMemo(() => invSerialIndex(onHand), [onHand.products]);
const [date, setDate] = invUseState(invTomorrow);
const [scans, setScans] = invUseState([]);
const [result, setResult] = invUseState(null);
const [busy, setBusy] = invUseState(false);
const record = PULLS.find((r) => r.date === date) || null;
const locked = !!(record && record.locked);
const run = invUseCallback(async (nextScans) => {
setBusy(true);
try { setResult(await InvApi.lensPull({ date, scans: nextScans })); }
catch (e) { toast('⚠️ ' + e.message, 'error'); }
setBusy(false);
}, [date, toast]);
// Reload whenever the day changes, picking up whatever was already scanned
// on this date so two people (or one person after a break) see one list.
invUseEffect(() => {
const saved = (stores.lens_pulls.data || []).find((r) => r.date === date);
const s = saved ? (saved.scans || []) : [];
setScans(s); run(s);
}, [date, stores.lens_pulls.version]);
const persistScans = async (next) => {
setScans(next);
await run(next);
const rest = PULLS.filter((r) => r.date !== date);
const rec = { ...(record || {}), date, scans: next, updatedAt: new Date().toISOString(), updatedBy: (me && (me.name || me.email)) || '' };
await savedOrConflict(stores.lens_pulls, [...rest, rec]);
};
const addScan = (s) => { if (!locked) persistScans([...scans, s]); };
const removeScan = (i) => { if (!locked) persistScans(scans.filter((_, idx) => idx !== i)); };
// A serial the system has never seen is nearly always a consigned lens that
// arrived without being received — so offer to receive it right here.
const receiveSerial = async (scan) => {
const p = P.find((x) => x.id === scan.productId);
if (!p) return;
try {
await invPostLines([{
type: 'received', productId: p.id, qty: 1, serial: scan.serial, lot: scan.lot || '', expiry: scan.expiry || '',
shelf: p.shelf || 'IOL', unitCost: Number(p.purchasePrice) || 0, uom: p.dispenseUom,
note: `Received at the lens pull for ${date}`, ref: { kind: 'other', id: 'lens-pull' },
}]);
toast(`${p.description} — serial ${scan.serial} received into stock`);
refreshAll && refreshAll();
run(scans);
} catch (e) { toast('⚠️ ' + e.message, 'error'); }
};
const setLock = async (lock) => {
const rest = PULLS.filter((r) => r.date !== date);
const now = new Date().toISOString();
const rec = {
...(record || {}), date, scans, locked: lock,
verifiedBy: lock ? ((me && (me.name || me.email)) || '') : '', verifiedAt: lock ? now : '',
summary: lock && result ? { expected: result.slots.length, covered: result.slots.filter((s) => s.matched).length } : (record && record.summary) || null,
updatedAt: now, updatedBy: (me && (me.name || me.email)) || '',
};
if (await savedOrConflict(stores.lens_pulls, [...rest, rec], lock ? 'Lens pull verified and locked' : 'Lens pull reopened')) {
InvApi.audit('INV_LENS_PULL', `${lock ? 'Verified' : 'Reopened'} the lens pull for ${date}`);
}
};
const slots = (result && result.slots) || [];
const problems = (result && result.problems) || { notNeeded: [], extra: [], unknown: [], serialNotInStock: [] };
const covered = slots.filter((s) => s.matched).length;
return (
The lenses set aside for a day's cases, from the Dispensary. Scan each box as you pull it. A second box of the same lens is taken as the backup; anything else is flagged.
setDate(e.target.value)} />
{busy ? 'Checking…' : `${covered} of ${slots.length} lenses accounted for`}
Scan every lens on the shelf, then check the shelf against the system. Nothing changes until you say so, and each correction is written into the stock history with the audit's date on it.
{a.counts.scanned} scanned · {a.counts.matched} matched · {a.counts.scannedNotInSystem} not in the system · {a.counts.inSystemNotScanned} not on the shelf
{a.by}
))}
)}
);
}
// ─── Returns: take a lens out of stock, and the vendor's own form ─
function InvLensReturns({ stores, savedOrConflict, toast, me, onHand, refreshAll }) {
const P = stores.products.data || [];
const S = stores.settings.data || {};
const lensStock = invUseMemo(() => {
const out = [];
for (const p of P) {
if (!p.isIol || p.active === false) continue;
const bal = onHand.products[p.id];
if (!bal) continue;
for (const lot of bal.lots) if (lot.onHand > 0) out.push({ product: p, lot });
}
return out.sort((a, b) => a.product.description.localeCompare(b.product.description));
}, [P, onHand.products]);
// ── take one lens out of stock ──
const [q, setQ] = invUseState('');
const [picked, setPicked] = invUseState(null);
const [reason, setReason] = invUseState('');
const [linkPatient, setLinkPatient] = invUseState('');
const [linkEye, setLinkEye] = invUseState('');
const [busy, setBusy] = invUseState(false);
const matches = invUseMemo(() => {
const n = invNorm(q);
if (n.length < 2) return [];
return lensStock.filter((r) => invNorm(r.product.description).includes(n) || invNorm(r.lot.serial).includes(n) || invNorm(r.lot.lot).includes(n)).slice(0, 12);
}, [q, lensStock]);
const removeLens = async () => {
if (!picked || !reason.trim()) return;
setBusy(true);
try {
await invPostLines([{
type: 'returned', productId: picked.product.id, qty: picked.lot.onHand, serial: picked.lot.serial || '', lot: picked.lot.lot || '',
shelf: picked.lot.shelf || '', unitCost: picked.lot.unitCost, uom: picked.product.dispenseUom,
note: reason.trim(),
ref: { kind: 'return', id: 'lens-return', ...(linkPatient ? { patientId: linkPatient } : {}), ...(linkEye ? { eye: linkEye } : {}) },
}]);
InvApi.audit('INV_LENS_RETURN', `${picked.product.description} SN ${picked.lot.serial} out of stock — ${reason.trim()}`);
toast(`${picked.product.description} taken out of stock`);
setPicked(null); setReason(''); setLinkPatient(''); setLinkEye(''); setQ('');
refreshAll && refreshAll();
} catch (e) { toast('⚠️ ' + e.message, 'error'); }
setBusy(false);
};
// ── the vendor's return form ──
const FORMS = (window.SurgSuiteLensForms || {}).LENS_RETURN_FORMS || {};
const [vendor, setVendor] = invUseState('jnj_expired');
const cfg = FORMS[vendor];
const defaults = (S.lensFormDefaults || {})[vendor] || {};
const [practice, setPractice] = invUseState(defaults);
const [formRows, setFormRows] = invUseState([]);
const [formQ, setFormQ] = invUseState('');
const [showAllMakers, setShowAllMakers] = invUseState(false);
invUseEffect(() => { setPractice(((stores.settings.data || {}).lensFormDefaults || {})[vendor] || {}); setFormRows([]); setShowAllMakers(false); }, [vendor]);
// A vendor's form only covers that vendor's own lenses, so the search offers
// theirs and says how many it is holding back.
const vendorMatch = (p) => window.SurgSuiteLensForms.lensFormVendorMatch(vendor, p);
const formSearch = invUseMemo(() => {
const n = invNorm(formQ);
if (n.length < 2) return { list: [], hidden: 0 };
const all = lensStock.filter((r) => invNorm(r.product.description).includes(n) || invNorm(r.lot.serial).includes(n));
const mine = all.filter((r) => vendorMatch(r.product) !== false);
return { list: (showAllMakers ? all : mine).slice(0, 12), hidden: showAllMakers ? 0 : all.length - mine.length };
}, [formQ, lensStock, showAllMakers, vendor]);
const formMatches = formSearch.list;
const mismatched = formRows.filter((r) => r._vendorMismatch);
const addFormRow = (r) => {
if (!cfg || formRows.length >= cfg.maxRows) { toast(`⚠️ ${cfg.label} takes at most ${cfg.maxRows} lenses on one sheet.`, 'error'); return; }
setFormRows([...formRows, {
...window.SurgSuiteLensForms.lensFormRowFromStock(vendor, r.product, r.lot),
_productId: r.product.id, _serial: r.lot.serial, _lot: r.lot.lot, _shelf: r.lot.shelf, _onHand: r.lot.onHand, _unitCost: r.lot.unitCost, _fromStock: true,
_maker: r.product.manufacturer || '', _vendorMismatch: vendorMatch(r.product) === false,
}]);
setFormQ('');
};
const generate = async () => {
if (!cfg || !formRows.length) return;
if (mismatched.length && !window.confirm(`${mismatched.length} lens(es) on this sheet were not made by ${cfg.label.split('—')[0].trim()} (${[...new Set(mismatched.map((r) => r._maker))].join(', ')}). A vendor will usually send the whole form back. Generate it anyway?`)) return;
setBusy(true);
try {
window.SurgSuiteLensForms.lensFormGenerate(vendor, { practice, date: invToday(), lenses: formRows });
// the practice's own details are the same every time — remember them
const nextSettings = { ...S, lensFormDefaults: { ...(S.lensFormDefaults || {}), [vendor]: practice } };
await savedOrConflict(stores.settings, nextSettings);
// lenses that came off the shelf go out of stock with the form
const lines = formRows.filter((r) => r._fromStock && r._productId).map((r) => ({
type: 'returned', productId: r._productId, qty: r._onHand || 1, serial: r._serial || '', lot: r._lot || '', shelf: r._shelf || '',
unitCost: r._unitCost, note: `${cfg.label} — returned on the vendor form`, ref: { kind: 'return', id: vendor },
}));
if (lines.length) { await invPostLines(lines); refreshAll && refreshAll(); }
toast(`${cfg.label} generated${lines.length ? ` — ${lines.length} lens(es) taken out of stock` : ''}`);
setFormRows([]);
} catch (e) { toast('⚠️ ' + e.message, 'error'); }
setBusy(false);
};
return (
Take a lens out of stock
For a lens going back to the vendor, borrowed by a rep, or otherwise leaving the shelf. Tie it to a patient and eye when it is a STAAR backup going back — that is what lets an invoice billing it afterwards be caught.
{picked ? (
{picked.product.description}{picked.lot.serial ? 'SN ' + picked.lot.serial : picked.lot.lot ? 'lot ' + picked.lot.lot : ''} · {invFmtQty(picked.lot.onHand)} on hand
setReason(e.target.value)} placeholder="e.g. shipped back to STAAR, tracking 1Z999… — or 'rep borrowed for demo'" />
setLinkPatient(e.target.value)} placeholder="name or MRN" />
) : (
setQ(e.target.value)} placeholder="Search the lenses on hand by name, serial or lot…" />
{matches.length > 0 && (
Each vendor wants their own certificate of destruction. Your practice details are remembered per vendor. Generating the form also takes those lenses out of stock.
Lenses a vendor sent for one named patient — STAAR ICLs above all, where several arrive and only one goes in. A lens appears here as soon as it is received with a patient on it, and its status is read straight from the stock history, so there is nothing to keep up to date by hand.
{lenses.length === 0 ? (
No consigned lenses yet. When a lens is received, fill in "ordered for patient" (and the eye and whether it is the primary or a backup) and it will show up here.