@propriety/court-calendar 1.0.150 → 1.0.152

package/README.md

@@ -211,6 +211,7 @@ Parameters use short keys to keep the address bar readable. Only non-default val
 | `view` | `view` | `'dayGridMonth'` | One of `dayGridMonth`, `timeGridWeek`, `timeGridDay`, `listDay`, `tableView` |
 | `date` | `date` | today | ISO `YYYY-MM-DD` |
 | `cdId` | `courtDateId` | absent | Integer court date ID — opens the details modal on load |
+| `cdType` | `courtDateType` | absent (SCAR) | Which table `cdId` belongs to: `Negotiations` or `Collections`. The three date types have independent ID sequences that overlap, so `cdId` alone can resolve to the wrong record. Omitted for SCAR dates; a link without it resolves SCAR-first. |
 | `ci` | `caseIdx` | absent | `Case.SCARIndexNumber` — opens a specific case (requires `cdId`) |
 | `ht` | `showVirtual` / `showInPerson` / `showUnknown` | all visible | Comma-separated list of **hidden** hearing types, e.g. `ht=virtual,inPerson` |
 | `user` | `showOnlyAssignedToUser` | `null` | UserID integer, or `-1` for "Unassigned" |

package/dist/__tests__/StatusTimeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/hooks/UseCourtDates.test.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Tests for the date-identity half of useCourtDates.
+ *
+ * The three date types come from tables with independent auto-increment sequences,
+ * so a CourtDateID is only unique *within* a type. Ids 225 and 227 exist in both
+ * Court.HearingDates and Court.NegotiationDates today, and Court.Collections reaches
+ * the same range once it passes the HearingDates start.
+ *
+ * Resolving a date by bare id therefore picked whichever list was searched first —
+ * always SCAR — so assigning a chair on negotiation 225 wrote to SCAR date 225.
+ */
+export {};

package/dist/__tests__/timelineStages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/_components/List/CalendarList.d.ts

@@ -1,8 +1,9 @@
+import { CourtDate } from '../../types';
 import { CalEvent } from '../../helpers/CalEvent';
 export default function CalendarList({ filteredDates, onSelectCalEvent, currentDate, onUpdateChair, isPrinting, }: {
     filteredDates: CalEvent[];
     onSelectCalEvent: (calEvent: CalEvent) => void;
     currentDate: Date;
-    onUpdateChair?: (courtDateId: number, position: 'first' | 'second', userId: number | null) => void;
+    onUpdateChair?: (courtDate: CourtDate, position: 'first' | 'second', userId: number | null) => void;
     isPrinting?: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/_components/Modal/DateDetails/timelineStages.d.ts

@@ -0,0 +1,51 @@
+import { Case } from '../../../types';
+import { Status } from './StatusTimeline';
+export interface StageResult {
+    status: Status;
+    count?: {
+        done: number;
+        total: number;
+    };
+    date?: Date;
+}
+/** Most recent of a set of possibly-missing dates, or undefined when none are set. */
+export declare function latestDate(dates: (Date | null | undefined)[]): Date | undefined;
+/**
+ * What an empty base means for a stage. The two cases are deliberately NOT symmetric:
+ *
+ *  - 'complete'   No work is left, so the stage is finished (green check). Used by
+ *                 Reviewed/Sent Offers/Uploaded: you cannot review, offer on, or upload
+ *                 for a case that already settled, so once every case is settled those
+ *                 stages are done by definition.
+ *  - 'notStarted' The stage cannot have begun yet (empty circle). Used by Stipulation:
+ *                 a stipulation only exists once a case settles, so "nothing settled"
+ *                 means not started, not finished.
+ */
+type EmptyBase = 'complete' | 'notStarted';
+/**
+ * Collapses one timeline stage into a status.
+ *
+ * `base` is the population the stage is measured against — the "X of Y" label is always
+ * done/base, never cases.length. `cases` is the full list on the date, used only to blank
+ * the timeline when the date has no cases at all, and to date the check when the base is
+ * empty but the stage still counts as complete.
+ */
+export declare function stageStatus({ cases, base, isDone, dateOf, whenBaseEmpty, }: {
+    cases: Case[];
+    base: Case[];
+    isDone: (c: Case) => boolean;
+    dateOf: (done: Case[]) => Date | undefined;
+    whenBaseEmpty: EmptyBase;
+}): StageResult;
+export declare function reviewedStage(cases: Case[], isVillage: boolean): StageResult;
+export declare function sentOffersStage(cases: Case[], isVillage: boolean): StageResult;
+export declare function uploadedStage(cases: Case[], isVillage: boolean): StageResult;
+/** Settled is the one stage measured against every case — it *is* the settlement rate. */
+export declare function settledStage(cases: Case[], isVillage: boolean): StageResult;
+/**
+ * Stipulations only exist on settled cases (~98% of stip rows in production sit on one),
+ * so "stips done / settled cases" is the meaningful ratio. Note the asymmetry with the
+ * stages above: an empty base here means not-started, not finished.
+ */
+export declare function stipulationStage(cases: Case[], isVillage: boolean): StageResult;
+export {};

package/dist/helpers/cases.d.ts

@@ -1,5 +1,15 @@
 import { CalendarFilterCtx, Case, NegotiationLog } from '../types';
 export declare function isCaseSettled(c: Case, isVillage: boolean): boolean;
+/**
+ * The raw upload fact: this case's evidence is up on NYSCEF. Says nothing about
+ * settlement — use this when settled cases have already been filtered out.
+ */
+export declare function hasCaseUploadedEvidence(c: Case): boolean;
+/**
+ * True when the case needs no upload — either it settled (mooting the upload) or the
+ * evidence is already up. This is the "nothing left to chase" predicate behind the
+ * calendar/week upload badges; it is NOT the Uploaded timeline stage.
+ */
 export declare function isCaseUploadedOrSettled(c: Case, isVillage: boolean): boolean;
 export declare function isCaseMissingEvidence(c: Case): boolean;
 export declare function hasCaseUnuploadedEvidence(c: Case): boolean;

package/dist/helpers/courtDates.d.ts

@@ -1,4 +1,4 @@
-import { Case, CourtDate } from '../types';
+import { DateType, Case, CourtDate } from '../types';
 export declare function isVillageDate(muniCode: string): boolean;
 /**
  * Parenthetical muni-code suffix for event labels, e.g. " (3100)". Collections may
@@ -16,5 +16,20 @@ export declare function caseIndexForMuni(muniCode: string, c: Pick<Case, 'SCARIn
  * Returns a unique string key for a court date suitable for use in the allCases map.
  * Negotiation IDs and SCAR IDs come from separate auto-increment sequences and can
  * overlap numerically, so negotiations are prefixed with "neg_".
+ *
+ * This is also the only safe way to *identify* a date: resolving one by CourtDateID
+ * alone silently picks whichever type is searched first. The sequences already overlap
+ * in production (ids 225 and 227 exist as both a SCAR date and a negotiation date), and
+ * Collections joins them once it passes the SCAR sequence's start.
  */
-export declare function caseKey(date: CourtDate): string;
+export declare function caseKey(date: Pick<CourtDate, 'DateType' | 'CourtDateID'>): string;
+/**
+ * The same key built from its parts, for callers holding an id and a type separately
+ * rather than a whole CourtDate — e.g. resolving the `cdId`/`cdType` URL pair.
+ */
+export declare function dateKeyOf(dateType: DateType | null | undefined, courtDateId: number): string;
+/**
+ * True for a plain SCAR court date. DateType.SCAR is the empty string, so an absent
+ * type reads as SCAR — matching how the API omits the field for court dates.
+ */
+export declare function isScarDate(date: Pick<CourtDate, 'DateType'>): boolean;

package/dist/helpers/formatter.d.ts

@@ -1,4 +1,5 @@
 import { Evidence } from '../types';
 export declare function formatDateForAPI(date: Date): string;
 export declare function formatDateTimeForAPI(date: Date, hearingTime?: string): string;
+export declare function to24Hour(time: string): string;
 export declare function formatEvidence(evidence: Evidence): string;

package/dist/helpers/routing.d.ts

@@ -1,8 +1,8 @@
-import { CalendarFilterCtx, CalendarRouteParams } from '../types';
+import { DateType, CalendarFilterCtx, CalendarRouteParams } from '../types';
 import { DEFAULT_FILTER_CTX } from '../constants';
-export declare const CALENDAR_PARAM_KEYS: readonly ["view", "date", "cdId", "ci", "ht", "user", "dl", "md", "adj", "dt", "muni", "settled", "noEvid", "unrev", "q"];
+export declare const CALENDAR_PARAM_KEYS: readonly ["view", "date", "cdId", "cdType", "ci", "ht", "user", "dl", "md", "adj", "dt", "muni", "settled", "noEvid", "unrev", "q"];
 export declare function serializeCalendarParams(params: CalendarRouteParams): URLSearchParams;
 export declare function parseCalendarSearchParams(params: URLSearchParams | Record<string, string | undefined>): CalendarRouteParams;
-export declare function buildCalendarRouteParams(view: string, date: Date, courtDateId: number | null, caseIdx: string | null, filterCtx: CalendarFilterCtx): CalendarRouteParams;
+export declare function buildCalendarRouteParams(view: string, date: Date, courtDateId: number | null, caseIdx: string | null, filterCtx: CalendarFilterCtx, courtDateType?: DateType | null): CalendarRouteParams;
 export declare function extractFilterFields(params: CalendarRouteParams): Partial<CalendarFilterCtx>;
 export { DEFAULT_FILTER_CTX };

package/dist/hooks/UseCourtDates.d.ts

@@ -35,6 +35,6 @@ export declare function useCourtDates({ apiKey, activeUser, modalIsOpen, setSele
     lastFetchedAt: Date | null;
     forceRefreshDates: () => Promise<void>;
     updateCourtDateInMemory: (updatedDate: CourtDate, del?: boolean) => void;
-    handleUpdateChair: (courtDateId: number, position: "first" | "second", userId: number | null) => void;
+    handleUpdateChair: (target: CourtDate, position: "first" | "second", userId: number | null) => void;
     loadRange: (from: Date, to: Date) => Promise<void>;
 };