@propriety/court-calendar 1.0.195 → 1.0.196

package/README.md

@@ -274,7 +274,7 @@ If a `cdId` or `ci` value in the URL doesn't match any loaded data, a brief erro
 | Hook | Description |
 |------|-------------|
 | `useCourtDates` | Fetches and caches court dates, negotiations, and collections. Handles polling and optimistic in-memory updates. |
-| `useCaseData` | Fetches and caches cases for all court dates. Maintains a `Record<caseKey, Case[]>` memory store. |
+| `useCaseData` | Fetches cases for the loaded court dates into a `Record<caseKey, Case[]>` memory store. Never cached, so a reload always fetches. |
 | `useCalendarEvents` | Derives FullCalendar event objects and `CalEvent` buckets from court date + case data. Applies filter context. |
 | `useModalSelection` | Tracks which court date event is selected and manages `openDetailsModal` / `openCreateModal`. |
 | `useModalState` | Manages form state for Edit/Create modes and `clickedCase` for Case Details mode. |
@@ -288,11 +288,11 @@ If a `cdId` or `ci` value in the URL doesn't match any loaded data, a brief erro
 |--------|-------------|
 | `helpers/routing.ts` | `parseCalendarSearchParams`, `serializeCalendarParams`, `buildCalendarRouteParams`, `extractFilterFields`. Pure functions for URL encoding/decoding. |
 | `helpers/CalEvent.ts` | `buildCalEvents` — derives main, extra-day, and adjournment `CalEvent` buckets from court date + case data. |
-| `helpers/cases.ts` | Case fetching (by court date, paginated, search). Settlement and evidence checks. |
+| `helpers/cases.ts` | Case predicates: settled, out for decision, evidence, search match. |
 | `helpers/courtDates.ts` | `caseKey` (memory-map key), `isVillageDate` (municipality code check), `isCountyCode` (one-letter county code). |
 | `helpers/documentActions.ts` | Open, download, and print document helpers (used by DocCard). |
 | `helpers/formatter.ts` | Date formatting for API (`YYYY-MM-DD` or `YYYY-MM-DD HH:mm:00`). Evidence string formatting. |
-| `helpers/cache.ts` | Dexie-based IndexedDB caching with TTL. |
+| `helpers/cache.ts` | Dexie-based IndexedDB caching of the court-date lists, with TTL. Cases are not cached. |
 | `helpers/api/` | Fetch wrappers for each API endpoint group (court dates, cases, munis, people). |
 
 ### CalEvent
@@ -454,7 +454,7 @@ All data is fetched from `https://utils.aventine.ai`. Every request requires the
 | `/court-dates/{id}` | DELETE | Delete a court date |
 | `/court-dates/{id}/cases` | GET | Fetch cases for a court date |
 | `/court-cases/search?term=...&page=...` | GET | Search cases (paginated) |
-| `/court-cases/filtering?page=...&page_size=...` | GET | List all cases (paginated) |
+| `/court-cases/by-court-dates` | POST | Cases for up to 1000 court dates, `{"ids": [...]}` → `{"cases": {id: [...]}}` |
 | `/court-cases/snooze/upload/{id}` | GET | Snooze upload deadline by 1 business day |
 | `/users/all` | GET | Fetch all users |
 | `/users/hearing-officers` | GET | Fetch hearing officers |
@@ -483,7 +483,7 @@ Publishing is automated via GitHub Actions (`.github/workflows/publish.yml`).
 ## Known limitations
 
 - **Port 8000 only:** The backend API enforces CORS that only allows requests from `localhost:8000`. Applies to the dev server and any locally running consumer.
-- **Cache is not invalidated on external changes:** If another user *modifies* a court date, the change won't appear until the local cache expires (1 minute for dates, 2 minutes for cases). A *deletion* does propagate: the poll drops any in-window date the server stops returning, and a save answered with 404 removes the row immediately — which matters because polling is suspended while a modal is open.
+- **Cache is not invalidated on external changes:** If another user *modifies* a court date, the change won't appear until the local cache expires (1 minute for dates). Cases are not cached, but a case edited in another tab shows only after a reload unless the edit changed its date's case count or day. A *deletion* does propagate: the poll drops any in-window date the server stops returning, and a save answered with 404 removes the row immediately — which matters because polling is suspended while a modal is open.
 - **No pagination for court dates:** `getAllDates` fetches every court date in a single request.
 - **Single API key:** No built-in token refresh or rotation.
 - **No error UI for API failures:** Network errors are logged to the console but not surfaced to the user (except for bootstrap errors, which show a brief snackbar).

package/dist/_components/DebugModal/sections/CaseComparison.d.ts

@@ -1,12 +1,10 @@
 import { Case } from '../../../types';
 export declare const DIFF_FIELDS: (keyof Case)[];
 export declare function fieldDiff(a: Case | undefined, b: Case | undefined, field: keyof Case): boolean;
-export declare function CaseComparisonSection({ allIndexNumbers, memById, cacheById, apiById, resolvedCache, loading }: {
+export declare function CaseComparisonSection({ allIndexNumbers, memById, apiById, loading }: {
     allIndexNumbers: string[];
     memById: Map<string, Case>;
-    cacheById: Map<string, Case>;
     apiById: Map<string, Case>;
-    resolvedCache: Case[] | null;
     loading: boolean;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function RawDiffSection({ diffCases, memById, apiById }: {

package/dist/_components/DebugModal/sections/CourtDateFields.d.ts

@@ -1,6 +1,4 @@
-import { Case, CourtDate } from '../../../types';
-export declare function CourtDateSection({ courtDate, cacheCases, resolvedCache }: {
+import { CourtDate } from '../../../types';
+export declare function CourtDateSection({ courtDate }: {
     courtDate: CourtDate;
-    cacheCases: Case[] | 'none' | null;
-    resolvedCache: Case[] | null;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/_components/LoadingBar.d.ts

@@ -1,10 +1,8 @@
 interface LoadingBarProps {
     isFetchingDates: boolean;
     isFetchingCases: boolean;
-    loadedCount: number;
-    totalCount: number;
     isSearching?: boolean;
     isFiltering?: boolean;
 }
-export default function LoadingBar({ isFetchingDates, isFetchingCases, loadedCount, totalCount, isSearching, isFiltering, }: LoadingBarProps): import("react/jsx-runtime").JSX.Element | null;
+export default function LoadingBar({ isFetchingDates, isFetchingCases, isSearching, isFiltering, }: LoadingBarProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/constants.d.ts

@@ -6,7 +6,6 @@ export declare const S3_DOCS_URL = "https://aventine-court-docs.s3.amazonaws.com
 export declare const SETTLED_ACTIONS: string[];
 export declare const EXCLUDED_USER_NAMES: string[];
 export declare const PRIMARY_USER_IDS: number[];
-export declare const CASES_CACHE_EXPIRY: number;
 export declare const COURT_DATES_CACHE_EXPIRY: number;
 export declare const NEGOTIATIONS_CACHE_EXPIRY: number;
 export declare const COLLECTIONS_CACHE_EXPIRY: number;

package/dist/helpers/api/cases.d.ts

@@ -1,7 +1,14 @@
 import { DateType, CourtDate, Case } from '../../types';
 export declare function searchByCaseTerm(term: string, apiKey: string): AsyncGenerator<any, void, unknown>;
 export declare function fetchCasesByCourtDate(id: string, apiKey: string, type?: DateType): Promise<Case[]>;
-export declare function fetchAllCasesPaginated(apiKey: string, pageSize?: number, dateFrom?: string): AsyncGenerator<Record<string, Case[]>, void, unknown>;
+/**
+ * Cases for many court dates (Court.HearingDates ids) in one request, keyed by CourtDateID. Each case
+ * is the thinner bulk shape: the open date's modal needs fetchCasesByCourtDate.
+ *
+ * Throws on a failed request after reporting it, so the caller can leave those dates unloaded
+ * rather than recording them as dates with no cases.
+ */
+export declare function fetchCasesForCourtDates(ids: string[], apiKey: string): Promise<Record<string, Case[]>>;
 export interface SkippedAdjournment {
     index_number: string | null;
     /** `ambiguous`, `not_found`, `no_index_number`, or `settled:<determination>` / `settled:SettleDate`. */

package/dist/helpers/cache.d.ts

@@ -1,19 +1,4 @@
-import { Case, CourtDate } from '../types';
-export declare function getCasesCache(): Promise<{
-    [courtDateId: string]: {
-        data: Case[];
-        timestamp: number;
-    };
-}>;
-export declare function setCasesCache(cache: {
-    [courtDateId: string]: {
-        data: Case[];
-        timestamp: number;
-    };
-}): Promise<void>;
-export declare function getCachedCases(courtDateId: string): Promise<Case[] | null>;
-export declare function updateCasesCache(courtDateId: string, data: Case[]): Promise<void>;
-export declare function removeCasesCache(courtDateId: string): Promise<void>;
+import { CourtDate } from '../types';
 export declare function clearAllCache(): Promise<void>;
 export declare function getCourtDatesCache(): Promise<CourtDate[] | null>;
 export declare function setCourtDatesCache(data: CourtDate[], ttl?: number): Promise<void>;

package/dist/hooks/UseCaseData.d.ts

@@ -1,27 +1,25 @@
 import { Case, CourtDate } from '../types';
 /**
- * Manages fetching, caching, and in-memory storage of cases for court dates.
+ * Manages fetching and in-memory storage of cases for court dates.
  *
- * Uses a three-tier lookup strategy for each court date ID:
- * 1. **Memory** – React state already holds the cases; no I/O needed.
- * 2. **Cache** – IndexedDB/session cache is checked for any IDs missing from memory.
- * 3. **API** – Remaining IDs are fetched; bulk pagination is used when >10 IDs are missing.
- *
- * State is updated incrementally as each tier resolves so the UI stays responsive.
+ * Each court date is served from memory if React state already holds its cases, otherwise from the
+ * API: per date for up to BULK_THRESHOLD SCAR dates, one bulk by-ids request above that. The open
+ * date always loads per date, because the bulk case is thinner than its modal reads. There is no
+ * browser cache: a reload starts from an empty memory, so every reload reaches the API.
  *
  * @param apiKey             API key forwarded to case fetch helpers.
- * @param courtDates         Full list of court dates; cases are loaded for every ID in this list.
+ * @param courtDates         The court dates to load cases for.
  * @param selectedCourtDate  The currently-selected court date; its cases are always force-refreshed
- *                           from the API (bypassing memory and cache) when the selection changes.
+ *                           from the API (bypassing memory) when the selection changes.
  *
  * @returns
- * - `allCases`                      – Map of `CourtDateID → Case[]` for all loaded court dates.
- * - `selectedCases`                 – Cases belonging to `selectedCourtDate`.
- * - `isFetchingCases`               – `true` while any API fetch is in flight.
- * - `forceRefreshCases`             – Re-fetches every court date from the API (manual refresh).
- * - `updateCases`                   – Optimistically merges a partial cases map into state and cache.
- * - `refreshCases`                  – Silently reconciles one court date with the server after a mutation.
- * - `deleteCaseMemoryAndCache`      – Removes all cases for a given court date from memory and cache.
+ * - `allCases`               – Map of `caseKey → Case[]` for all loaded court dates.
+ * - `selectedCases`          – Cases belonging to `selectedCourtDate`.
+ * - `isFetchingCases`        – `true` while any non-silent fetch is in flight.
+ * - `forceRefreshCases`      – Re-fetches every court date from the API (manual refresh).
+ * - `updateCases`            – Optimistically merges a partial cases map into state.
+ * - `refreshCases`           – Silently reconciles one court date with the server after a mutation.
+ * - `deleteCasesFromMemory`  – Removes all cases for a given court date from memory.
  */
 export declare function useCaseData({ apiKey, courtDates, selectedCourtDate, }: {
     apiKey: string;
@@ -32,7 +30,7 @@ export declare function useCaseData({ apiKey, courtDates, selectedCourtDate, }:
     selectedCases: Case[];
     isFetchingCases: boolean;
     forceRefreshCases: () => void;
-    updateCases: (cases: Record<string, Case[]>) => Promise<void>;
+    updateCases: (cases: Record<string, Case[]>) => void;
     refreshCases: (courtDate: CourtDate) => Promise<void>;
-    deleteCaseMemoryAndCache: (courtDateID: string) => Promise<void>;
+    deleteCasesFromMemory: (courtDateID: string) => void;
 };