@propriety/court-calendar 1.0.149 → 1.0.151

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

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

package/dist/__tests__/helpers/dateHistory.test.d.ts

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

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

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

package/dist/_components/Modal/CaseDetails/CaseDetails.d.ts

@@ -1,6 +1,9 @@
-import { Case } from '../../../types';
+import { AdjournmentEntry, Case, DateEditItem } from '../../../types';
 declare const CaseDetails: import('react').NamedExoticComponent<{
     selectedCase: Case | null;
     isVillage: boolean;
+    muniCode?: string;
+    adjournments?: AdjournmentEntry[];
+    courtDateHistory?: DateEditItem[];
 }>;
 export default CaseDetails;

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

@@ -1,8 +1,10 @@
-import { Case, CourtDate } from '../../../types';
-export default function DateDetails({ selectedCourtDate, cases, isVillage, isFetchingCases, onUpdateChair, }: {
+import { AdjournmentEntry, Case, CourtDate, DateEditItem } from '../../../types';
+export default function DateDetails({ selectedCourtDate, cases, isVillage, isFetchingCases, onUpdateChair, adjournments, courtDateHistory, }: {
     selectedCourtDate: CourtDate | null;
     cases: Case[];
     isVillage: boolean;
     isFetchingCases?: boolean;
     onUpdateChair?: (position: 'first' | 'second', userId: number | null) => void;
+    adjournments?: AdjournmentEntry[];
+    courtDateHistory?: DateEditItem[];
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { HistoryEntry } from '../../../helpers/dateHistory';
+/**
+ * Compact, newest-first trail of everything that has moved this court date — reschedules
+ * and bulk case adjournments. Renders nothing when there is no history, so unchanged court
+ * dates keep their header exactly as it was.
+ */
+export default function DateHistory({ entries, align, }: {
+    entries: HistoryEntry[];
+    align?: 'center' | 'flex-start';
+}): import("react/jsx-runtime").JSX.Element | null;

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/_components/Modal/Layout/ModalActions.d.ts

@@ -1,9 +1,11 @@
 import { ModalMode } from '../types';
-export default function ModalActions({ modalMode, onDelete, onSave, setModalMode, setIsOpen, isAdmin, }: {
+export default function ModalActions({ modalMode, onDelete, onSave, setModalMode, setIsOpen, isAdmin, createdBy, createdOn, }: {
     modalMode: ModalMode;
     onDelete: () => void;
     onSave: () => void;
     setModalMode: (mode: ModalMode) => void;
     setIsOpen: (isOpen: boolean) => void;
     isAdmin: boolean;
+    createdBy?: number | null;
+    createdOn?: Date | string | null;
 }): import("react/jsx-runtime").JSX.Element;

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

@@ -1,8 +1,17 @@
-import { DateType, CourtDate, DateEditLog } from '../../types';
+import { DateType, CourtDate, CourtDateDetail, DateEditLog } from '../../types';
 export declare function getAllDates(apiKey: string, type?: DateType, dateFrom?: string, dateTo?: string): Promise<Array<CourtDate>>;
 export declare function updateCourtDate(courtDateId: number, updatedData: Partial<CourtDate>, apiKey: string, courtCases?: string[], user?: number, type?: DateType, skipMotion?: boolean, noticeFiles?: File[]): Promise<boolean>;
 export declare function getCourtDate(courtDateId: number, apiKey: string, type?: DateType): Promise<CourtDate | null>;
+/**
+ * The full GET /court-dates/{id} payload, including the two history fields `getCourtDate`
+ * discards. Kept separate from `getCourtDate` so callers that only want the date itself
+ * (e.g. the post-save refresh in UseModalActions) keep their narrow return type.
+ *
+ * The negotiation branch of the endpoint returns neither `adjournments` nor the `CourtDate`
+ * edit-log trail, so both come back empty for negotiation dates rather than throwing.
+ */
+export declare function getCourtDateDetail(courtDateId: number, apiKey: string, type?: DateType): Promise<CourtDateDetail | null>;
 export declare function deleteCourtDate(courtDateId: number, apiKey: string, type?: DateType): Promise<boolean>;
-export declare function createCourtDate(courtDate: Date, muniCode: string, apiKey: string, courtCases?: string[], hearingTime?: string, multipleDates?: Date[], type?: DateType, noticeFiles?: File[]): Promise<number | null>;
+export declare function createCourtDate(courtDate: Date, muniCode: string, apiKey: string, courtCases?: string[], hearingTime?: string, multipleDates?: Date[], type?: DateType, noticeFiles?: File[], editUser?: number): Promise<number | null>;
 export declare function snoozeUploadDeadline(courtDateId: number, apiKey: string): Promise<boolean>;
 export declare function getDateEditLogs(courtDateId: number, apiKey: string, type?: DateType): Promise<DateEditLog | null>;

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/dateHistory.d.ts

@@ -0,0 +1,50 @@
+import { AdjournmentEntry, Case, DateEditItem, User } from '../types';
+export interface HistoryEntry {
+    /** Stable React key. */
+    key: string;
+    kind: 'reschedule' | 'adjournment';
+    /** When the change was recorded. Used for ordering. */
+    at: Date | null;
+    /** Reschedule only — the date it moved off of. */
+    from: Date | null;
+    /** The date it moved to (reschedule) or was adjourned to (adjournment). */
+    to: Date | null;
+    /** Adjournment only — how many cases share this adjourned-to date. */
+    caseCount: number;
+    /** Resolved user name, or '—' when unattributable. Adjournment rows are never attributed. */
+    by: string;
+}
+/**
+ * Parse a date coming out of the history payloads.
+ *
+ * Two formats arrive here: the edit log stores `"2026-04-22 10:00:00"` (a space, no zone),
+ * while serialized `AdjournmentDate` values are ISO. Both are parsed from their Y-M-D parts
+ * as *local* time — `new Date("2026-04-22")` would be read as UTC and render as the previous
+ * day for anyone west of Greenwich, which is the same trap `formatDate` in DateDetails guards.
+ */
+export declare function parseHistoryDate(value: Date | string | null | undefined): Date | null;
+/**
+ * Resolve an edit-log `UpdatedBy` to a display name.
+ *
+ * The underlying column is a varchar that in practice holds user IDs, the literal 420,
+ * usernames, and NULL. Anything that doesn't resolve to a known user becomes '—' rather
+ * than a meaningless "User 420".
+ */
+export declare function resolveUserName(updatedBy: number | string | null | undefined, allUsers: Record<number, User>): string;
+/**
+ * Merge the court date's reschedule trail with its case adjournments into one
+ * time-ordered list, newest first.
+ *
+ * Adjournments are grouped by the date they were adjourned *to*, so a bulk adjournment of
+ * 20 cases onto one date collapses into a single entry. Without this the header trail would
+ * be 20 identical chips — CourtDateID 296 is exactly that shape in production.
+ */
+export declare function buildDateHistory(courtDateHistory: DateEditItem[], adjournments: AdjournmentEntry[], allUsers: Record<number, User>): HistoryEntry[];
+/**
+ * The adjournment rows belonging to a single case.
+ *
+ * Village dates key on VillageSCARIndexNumber and town dates on SCARIndexNumber, so the
+ * muni decides which index to match on — matching the wrong one silently returns nothing.
+ * `caseIndexForMuni` is the single source of truth for that rule.
+ */
+export declare function adjournmentsForCase(adjournments: AdjournmentEntry[], muniCode: string, c: Pick<Case, 'SCARIndexNumber' | 'VillageSCARIndexNumber'>): AdjournmentEntry[];

package/dist/hooks/UseDateHistory.d.ts

@@ -0,0 +1,17 @@
+import { AdjournmentEntry, CourtDate, DateEditItem } from '../types';
+/**
+ * Fetches the history side of `GET /court-dates/{id}` — the case adjournment rows and the
+ * trail of CourtDate reschedules.
+ *
+ * Lives at the modal level rather than inside a panel because every `ModalPanel` stays
+ * mounted (they cross-fade rather than unmount), so fetching per-panel would fire the same
+ * request from both the details header and the case details panel.
+ *
+ * @param selectedCourtDate  The court date currently displayed in the modal.
+ * @param modalIsOpen        Whether the modal is open; nothing is fetched while closed.
+ */
+export declare function useDateHistory(selectedCourtDate: CourtDate | null, modalIsOpen: boolean): {
+    adjournments: AdjournmentEntry[];
+    courtDateHistory: DateEditItem[];
+    isLoading: boolean;
+};