/* Fincr 2.0 — Rotations overview page (C2-D104; closed-positions section C2-D120).
Two sections, deliberately separate vocabularies (see decisions.md [C2-D120] for why):
01 — Open positions: which partial-sells on still-open holdings are
LINKED / AUTO·PENDING / UNLINKED across the whole book. Status via
f2ComputeRotationStatuses (store2.jsx) — UNTOUCHED by C2-D120.
02 — Closed positions: untagged / fully allocated / partially allocated / exit,
via the new f2ComputeClosedRotationStatuses below (scoped to `closed` only —
does not read or modify open-holding state, does not touch store2.jsx).
Row actions: section 01 opens the shared C2-D103 editor (SellRotationModal2); section
02 opens the shared ClosedReviewModal2 (closedpositions2.jsx) — both reused as-is, no
duplicate editors.
Exports window.RotationsTab2. */
/* C2-D120 — closed-position rotation status. Pure, scoped to `closed` (closed_positions)
only — mirrors f2ComputeRotationStatuses' shape/spirit but is NOT a modification of it;
open-position status is completely untouched. Vocabulary (locked in the spec, grounded
in real data from the scoping pass):
untagged — !sell_type (identical predicate to store2.jsx's untaggedClosedCount)
exit — sell_type:'exit' — settled, never counts as needing attention
fully_allocated — sell_type:'rotate' AND proceeds - Σ(portion_eur) <= 0.50
partially_allocated — sell_type:'rotate', gap > 0.50 — NEUTRAL, not an error (leftover
proceeds can legitimately just be untagged realized gain)
`usingLegacyProceeds` (proceeds field absent, e.g. OP) reuses the exact existing fallback
from ClosedReviewModal2 (closedpositions2.jsx:323-326: sellPrice * qty) — same figure,
same "approximate" framing, not reinvented here.
`hasIncompleteLink` is the existing, DISTINCT unlinkedRotationCount concept (store2.jsx:
675-679) — a rotate-tagged link with no target_txn_id yet — surfaced as a separate note,
never folded into the main status label (per spec, these are different questions:
"is there enough money accounted for" vs. "is this specific link still a placeholder"). */
function f2ComputeClosedRotationStatuses(closed) {
return (closed || []).map((c) => {
const untagged = !c.sell_type;
const usingLegacyProceeds = c.proceeds == null;
const proceeds = c.proceeds != null
? c.proceeds
: (c.sellPrice != null && c.qty != null) ? c.sellPrice * c.qty : null;
const links = c.rotation_links || [];
const linkedSum = links.reduce((s, l) => s + (l.portion_eur || 0), 0);
const gap = proceeds != null ? proceeds - linkedSum : null;
const hasIncompleteLink = c.sell_type === 'rotate' && links.length > 0
&& links.some((l) => l.target_txn_id == null);
let status;
if (untagged) status = 'untagged';
else if (c.sell_type === 'exit') status = 'exit';
else if (c.sell_type === 'rotate') status = (gap != null && gap <= 0.5) ? 'fully_allocated' : 'partially_allocated';
else status = 'untagged'; // defensive: any unrecognised sell_type value
return {
entry: c, id: c.id || null, ticker: c.ticker, closedAt: c.closedAt, status: status,
proceeds: proceeds, usingLegacyProceeds: usingLegacyProceeds,
linkedSum: linkedSum, gap: gap, hasIncompleteLink: hasIncompleteLink,
targets: links.map((l) => l.target_ticker),
};
});
}
function RotationsTab2() {
const t = useTheme2();
const store = useStore2();
const F = window.FINCR;
const [openSell, setOpenSell] = React.useState(null); // { sellTicker, sellTxnId, suggested? }
const [reviewKey, setReviewKey] = React.useState(null); // { id } or { ticker, closedAt } for legacy
const statuses = (typeof window.f2ComputeRotationStatuses === 'function')
? window.f2ComputeRotationStatuses(store.holdings) : [];
const byId = {};
statuses.forEach((s) => { byId[s.sellTxnId] = s; });
// Join status onto the live sell txns (for date/qty/price/proceeds), most recent first.
const rows = [];
(store.holdings || []).forEach((h) => (h.txns || []).forEach((tx) => {
if (tx.kind !== 'sell') return;
const st = byId[tx.id] || { status: 'unlinked' };
rows.push({ ticker: h.ticker, tx: tx, status: st.status, targets: st.targets, suggested: st.suggested });
}));
rows.sort((a, b) => (a.tx.date < b.tx.date ? 1 : (a.tx.date > b.tx.date ? -1 : 0)));
const linkedCount = rows.filter((r) => r.status === 'linked').length;
const pendingCount = rows.filter((r) => r.status === 'pending').length;
const unlinkedCount = rows.filter((r) => r.status === 'unlinked').length;
// Live tx for the editor (kept fresh from the store, not the click-time snapshot).
const editing = openSell
&& ((store.holdings || []).find((h) => h.ticker === openSell.sellTicker) || {}).txns;
const editingTx = editing ? editing.find((x) => x.id === openSell.sellTxnId) : null;
// C2-D120 — closed-position rows, most recently closed first. Same "always live, never a
// click-time snapshot" discipline as editingTx above: reviewKey stores only an identifier
// (stable id when present, ticker+closedAt fallback for legacy entries — the exact
// C2-D113 matching convention), and the live entry is looked up fresh on every render.
const closedStatuses = f2ComputeClosedRotationStatuses(store.closed);
const closedRows = closedStatuses.slice().sort((a, b) => (a.closedAt < b.closedAt ? 1 : (a.closedAt > b.closedAt ? -1 : 0)));
const untaggedClosedCount = closedRows.filter((r) => r.status === 'untagged').length;
const fullyAllocatedCount = closedRows.filter((r) => r.status === 'fully_allocated').length;
const partiallyAllocatedCount = closedRows.filter((r) => r.status === 'partially_allocated').length;
const exitCount = closedRows.filter((r) => r.status === 'exit').length;
const reviewEntry = reviewKey
? (store.closed || []).find((c) => (reviewKey.id ? c.id === reviewKey.id : (c.ticker === reviewKey.ticker && c.closedAt === reviewKey.closedAt)))
: null;
const eur = (n, d) => F.eur(n, d);
const cols = '150px 1fr 210px 116px';
const statusCell = (r) => {
if (r.status === 'linked') {
const label = (r.targets && r.targets.length === 1) ? r.targets[0] : ((r.targets || []).length + ' buys');
return (
linked→ {label}
);
}
if (r.status === 'pending') {
return (
auto · pending→ {r.suggested.buyTicker}?
);
}
return unlinked;
};
// C2-D120 (simplified per direct owner feedback, same day) — closed-section status cell.
// Just ticker + status chip, matching the open-positions rows' visual weight — a fast-scan
// overview, not a detail view. Target breakdown, leftover-€ figure, and the full legacy/
// approximate-proceeds sentence all still live in ClosedReviewModal2 (one click away via
// Edit); duplicating them inline here was the exact complaint. Owner chose to drop the
// legacy marker entirely rather than keep a wordless trace — clicking through is enough.
// `partially_allocated` deliberately uses the same neutral "mute" tone as `unlinked`, NOT
// an amber/warning tone — leftover proceeds are a legitimate, common outcome (real example:
// MRVL), not a mistake to flag.
const closedStatusCell = (r) => {
if (r.status === 'untagged') return untagged;
if (r.status === 'exit') return exit;
if (r.status === 'fully_allocated') return fully allocated;
return partially allocated; // partially_allocated
};
return (
{/* intro */}
LEDGER · ROTATIONS
Rotations
When you sell one holding to fund another, Fincr matches the proceeds automatically — but only inside a tight window. Link the ones it missed by hand, so realized P&L and cost basis stay honest.