kaafil-react-uikit 0.11.7 → 0.12.0

package/CHANGELOG.md

@@ -6,6 +6,51 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this package uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 While on `0.x` a minor bump may carry a breaking change; the entry will say so.
 
+## [0.12.0] — 2026-09-18
+
+### Changed
+
+- **Peer floor moves to `kaafil-js@^0.8.0`**, which is why this is a minor and
+  not a patch: a consumer pinned to `0.7.x` can no longer install this version.
+  The previous floor move was shipped as a patch; that understated it, and this
+  entry says so rather than repeating it.
+
+  0.8.0 makes a drain pull the lanes it applied something on. That closes the
+  gap 0.11.8 documented under "Known": a write enqueued without an
+  `entity`/`optimistic` pairing reaches the server and leaves the local
+  snapshot untouched, so a snapshot-backed list stayed missing its own
+  successful write until the screen was reopened. The Recent expenses list on
+  the manager's Money tab was the case found in the field. Nothing in this
+  package changed for it — the fix is in the engine, and this floor is how a
+  consumer actually gets it.
+
+## [0.11.8] — 2026-09-18
+
+### Fixed
+
+- **"Spend logged" read ₹0 with the money already spent.** `ManagerMoneySection`
+  summed the snapshot-backed `expenses[]` rows for that tile. `useExpenses`
+  deliberately enqueues its writes without an optimistic row — a fabricated
+  `ExpenseResponse` would have to guess `floatMovementId`, `receiptRequired`
+  and the negative-float guard, none of which a client can compute — so a
+  freshly logged expense is absent from that array until a pull brings it down,
+  and the tile showed zero until the manager reopened the app.
+
+  The tile now reads `totals.spendTotalMinor`, the server's own spend rollup,
+  which the hook already re-reads on every `sync.drained`. That is also simply
+  more correct than summing whichever rows this device happens to hold. The
+  local sum stays as the offline fallback, since `spendTotalMinor` is
+  documented as `undefined` until a read lands and must never be drawn as zero.
+
+### Known
+
+- The **Recent expenses list** on the same screen still fills only on the next
+  pull, for the same reason: no optimistic row, and `sync.drained` is emitted
+  without a pull following it. The tile above it is now correct either way.
+  Closing the gap properly means either fabricating a row with server-assigned
+  fields (rejected, above) or pulling after every drain, which is an engine-wide
+  change rather than a component one.
+
 ## [0.11.7] — 2026-09-18
 
 ### Fixed

package/dist/manager/index.cjs

@@ -6043,7 +6043,37 @@ function ReadyManagerMoneySection({
           issuedMinor: floatRow.issuedMinor,
           currency: floatRow.currency
         } : void 0,
-        spend: expensesReady !== void 0 ? { amountMinor: sumSpendMinor(active), currency } : void 0,
+        spend: (
+          /*
+           * THE SERVER'S OWN ROLLUP FIRST, the local sum only as a fallback.
+           *
+           * This summed `active` — the snapshot-backed rows — and nothing
+           * else. `useExpenses` deliberately enqueues its writes WITHOUT an
+           * optimistic row (its own DECISION comment: a fabricated
+           * `ExpenseResponse` would have to guess `floatMovementId`,
+           * `receiptRequired` and the negative-float guard, none of which a
+           * client can compute). That decision is right, and its consequence
+           * is that a freshly logged expense is absent from `expenses[]` until
+           * a pull brings it down — so this tile read ₹0 with the money
+           * already spent, on the one screen a manager checks it on.
+           *
+           * `totals.spendTotalMinor` is the server's own spend rollup and the
+           * hook already re-reads it on every `sync.drained`, so it reflects
+           * the write as soon as the queue reaches the server. Using it here
+           * is also simply more correct than summing whichever rows this
+           * device happens to hold.
+           *
+           * The local sum stays as the fallback rather than the primary. Its
+           * own doc says `spendTotalMinor` is `undefined` until a read lands
+           * and must never be drawn as zero — offline, where that read cannot
+           * happen, a sum of the rows actually held is the honest answer, and
+           * it is what offline-first means here.
+           */
+          expensesReady !== void 0 ? {
+            amountMinor: expensesReady.totals.spendTotalMinor ?? sumSpendMinor(active),
+            currency
+          } : void 0
+        ),
         collect: collectionsReady !== void 0 ? {
           amountMinor: balancesDueRows.reduce((sum, row) => sum + row.outstandingMinor, 0),
           travellerCount: balancesDueRows.length,