@propriety/court-calendar 1.0.155 → 1.0.157

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

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

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

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

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

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

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

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

package/dist/__tests__/fixtures.d.ts

@@ -1,6 +1,8 @@
 import { Case, CourtDate, CalendarFilterCtx } from '../types';
+import { OpenCase } from '../helpers/api/cases';
 export declare const MOCK_API_KEY = "test-api-key-123";
 export declare const MOCK_USER_ID = 42;
 export declare function makeCourtDate(overrides?: Partial<CourtDate>): CourtDate;
+export declare function makeOpenCase(overrides?: Partial<OpenCase>): OpenCase;
 export declare function makeCase(overrides?: Partial<Case>): Case;
 export declare const DEFAULT_FILTER_CTX: CalendarFilterCtx;

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

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

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

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

package/dist/_components/Modal/DateEdit/OpenCaseSelector.d.ts

@@ -0,0 +1,20 @@
+import { Case } from '../../../types';
+/**
+ * The Case IDs list rendered as a pick-list of the muni's open cases, with the client name
+ * alongside each one — so a hearing notice that names only "Bonaimo" can be resolved to an
+ * index number without leaving the form.
+ *
+ * There is no selection state of its own: a row is checked exactly when its case is already
+ * in `editedCases`, which is the same array the manual text fields edit. That is what makes
+ * switching between the two modes seamless, and it means a checked row can never drift out
+ * of sync with what will actually be saved.
+ */
+export default function OpenCaseSelector({ muniCode, isVillage, editedCases, setEditedCases, isParcelIdMode, setIsParcelIdMode, defaultYear, }: {
+    muniCode: string;
+    isVillage: boolean;
+    editedCases: Case[];
+    setEditedCases: (cases: Case[]) => void;
+    isParcelIdMode: boolean[];
+    setIsParcelIdMode: (toggles: boolean[]) => void;
+    defaultYear: number;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/_components/Modal/DateEdit/TextFieldList.d.ts

@@ -1,4 +1,5 @@
-export default function TextFieldList({ textFields, setTextFields, label, fieldLabelPrefix, toggleStates, setToggleStates, alternateFieldLabelPrefix, }: {
+import { default as React } from 'react';
+export default function TextFieldList({ textFields, setTextFields, label, fieldLabelPrefix, toggleStates, setToggleStates, alternateFieldLabelPrefix, headerAction, }: {
     textFields: string[];
     setTextFields: (fields: string[], toggles?: boolean[]) => void;
     label: string;
@@ -6,4 +7,6 @@ export default function TextFieldList({ textFields, setTextFields, label, fieldL
     toggleStates?: boolean[];
     setToggleStates?: (toggles: boolean[]) => void;
     alternateFieldLabelPrefix?: string;
+    /** Rendered at the end of the header row — e.g. an alternative way to fill the list. */
+    headerAction?: React.ReactNode;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/_components/Shared/CountyDropdown.d.ts

@@ -0,0 +1,15 @@
+/**
+ * County picker for collections dates, which are scheduled for a whole county rather
+ * than one municipality. The selected value is stored in the same MuniCode field every
+ * other date type uses, but holds a county code ('N') instead of a muni code ('N2000').
+ *
+ * Deliberately not part of MuniDropdown: only collections may pick a county, and county
+ * entries must never appear in the municipality list.
+ */
+export default function CountyDropdown({ selectedCounty, setSelectedCounty, size, onOpen, onClose, }: {
+    selectedCounty: string | null;
+    setSelectedCounty: (countyCode: string) => void;
+    size: 'small' | 'medium';
+    onOpen?: () => void;
+    onClose?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/_components/Shared/SearchBar.d.ts

@@ -1,5 +1,6 @@
-export default function SearchBar({ searchTerm, setSearchTerm, width, }: {
+export default function SearchBar({ searchTerm, setSearchTerm, width, placeholder, }: {
     searchTerm: string;
     setSearchTerm: (term: string) => void;
     width?: string | number;
+    placeholder?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/context/ReferenceDataContext.d.ts

@@ -5,6 +5,7 @@ interface ReferenceDataContextType {
     allUsers: Record<number, User>;
     allHearingOfficers: Record<number, HearingOfficer>;
     allMuniNames: Record<string, Muni>;
+    allCounties: Record<string, string>;
     getTownshipName: (muniCode: string) => string;
     getCountyName: (muniCode: string) => string;
     isLoading: boolean;

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

@@ -48,4 +48,36 @@ export declare function uploadMotionToPreclude(courtDateId: number, apiKey: stri
     test?: boolean;
     userId?: number;
 }): Promise<MotionUploadResult>;
+/**
+ * A case returned by /court-cases/open-cases — a much thinner record than `Case`, carrying
+ * only what the picker needs to identify a property by owner name.
+ *
+ * `SCARIndexNumber` holds whichever index applies to the level queried: the backend aliases
+ * `VillageSCARIndexNumber AS SCARIndexNumber` for village munis, so there is one index field
+ * and it is always the right one. `retainer_name` is the *retainer*, not necessarily the
+ * assessment-roll owner, and both it and `Address` are nullable (they come from LEFT JOINs).
+ */
+export interface OpenCase {
+    ParcelID: string;
+    SCARIndexNumber: string;
+    Year: number;
+    retainer_name: string | null;
+    Address: string | null;
+}
+/**
+ * Open (filed, unscheduled, unsettled) cases for a municipality and tax year.
+ *
+ * **Pass the court date's `MuniCode` verbatim — do not pad it.** The backend derives two
+ * things from this one string, and padding breaks both:
+ *  - It decides town vs village by `len(muni_code) > 3`, so padding "S05" to "S0500" makes it
+ *    run the *village* query for a town date.
+ *  - It matches `ParcelID LIKE '<muni_code>%'`. A town's SCAR calendar legitimately includes
+ *    parcels sitting inside its villages ("S0501-…" carries a town index number), so the
+ *    short code is what selects the right population, not an over-broad one.
+ *
+ * Unlike its siblings this *throws* on a non-OK response instead of returning []. The picker
+ * has to tell "the request failed" apart from "this muni has no open cases", and a silent
+ * empty array reads as the latter.
+ */
+export declare function fetchOpenCases(muniCode: string, year: number, apiKey: string): Promise<OpenCase[]>;
 export declare function updateCaseAdjournment(parcelId: string, scarIndexNumber: string, adjournedDate: Date | null, apiKey: string): Promise<boolean>;

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

@@ -0,0 +1,12 @@
+/**
+ * County code -> county name, e.g. { N: 'Nassau', W: 'Westchester' }.
+ *
+ * A county code is the single letter every municipality code starts with, so 'N'
+ * covers all of Nassau just as 'N2000' covers Hempstead. Collections dates are
+ * scheduled per county rather than per municipality and store one of these codes
+ * in MuniCode.
+ *
+ * Deliberately a separate endpoint from /utils/get-muni-names: county codes must
+ * not appear in the municipality dropdown.
+ */
+export declare function getAllCounties(apiKey: string): Promise<Record<string, string>>;

package/dist/helpers/eventLabel.d.ts

@@ -0,0 +1,52 @@
+import { DateType } from '../types';
+/**
+ * The pieces every surface builds a date's label from.
+ *
+ * Kept as parts rather than a finished string because the surfaces compose them
+ * differently: the calendar wants one line, the week widget stacks two, and the table
+ * already has its own Type and County columns and only needs the place.
+ */
+export interface DateLabelParts {
+    /** 'Collections' | 'Negotiations'. Null for SCAR — a court date is the default. */
+    typeWord: string | null;
+    /** County for Collections, township/village otherwise. '' when unresolvable. */
+    place: string;
+    /** ' (3100)' — SCAR only. Non-court types drop the code. */
+    codeSuffix: string;
+    /**
+     * Whether a case count means anything. SCAR only: collections are scheduled
+     * without cases, and negotiation dates are never linked to any, so both would
+     * show a permanent "x0".
+     */
+    showCaseCount: boolean;
+}
+/**
+ * Resolve a date's label parts.
+ *
+ * `getTownshipName` and `getCountyName` come from `useReferenceData()` — passed in
+ * rather than imported so this stays a pure function that tests can drive directly.
+ */
+export declare function dateLabelParts(dateType: DateType | null | undefined, muniCode: string, getTownshipName: (muniCode: string) => string, getCountyName: (muniCode: string) => string): DateLabelParts;
+/**
+ * One line naming the date, with no counts or day/adjournment markers.
+ * Used by the tooltip, the details modal header and anywhere a plain title is wanted.
+ */
+export declare function dateHeadline(parts: DateLabelParts): string;
+export interface EventTitleOptions {
+    /** Marks the occurrence as an adjournment: "Greenburgh (A) (3100)". */
+    adjourned?: boolean;
+    /** 1-based day for a multi-date hearing; omitted for a single-day date. */
+    dayNumber?: number;
+    /** Open case count, appended as "x4" when the type supports counts. */
+    unsettled?: number;
+    /** Leading verb for derived events, e.g. 'Upload' or 'Can Preclude'. */
+    prefix?: string;
+}
+/**
+ * The FullCalendar event title.
+ *
+ * Carries no time — FullCalendar renders that itself from the event's `start`, using
+ * the `eventTimeFormat` set on the calendar, and prepends it. So a collections event
+ * reads "1pm Collections Nassau" on screen while this returns "Collections Nassau".
+ */
+export declare function formatEventTitle(parts: DateLabelParts, options?: EventTitleOptions): string;

package/dist/helpers/formatter.d.ts

@@ -9,4 +9,12 @@ export declare function formatDisplayDate(date: Date | string | null | undefined
 export declare function formatDateForAPI(date: Date): string;
 export declare function formatDateTimeForAPI(date: Date, hearingTime?: string): string;
 export declare function to24Hour(time: string): string;
+/**
+ * A stored hearing time as "1pm" / "9:30am", or "" when there is nothing to show.
+ *
+ * Matches the `eventTimeFormat` the calendar passes to FullCalendar, so a chip rendered
+ * outside FullCalendar reads the same as the event it refers to. Accepts anything
+ * `to24Hour` accepts — "13:00:00" from Collections, "2:30 PM" from a picker, "10:30".
+ */
+export declare function formatClockTime(time: string | null | undefined): string;
 export declare function formatEvidence(evidence: Evidence): string;

package/dist/helpers/openCases.d.ts

@@ -0,0 +1,108 @@
+import { Case } from '../types';
+import { OpenCase } from './api/cases';
+/** A grid row: an OpenCase plus the stable id the DataGrid and the selection Map key on. */
+export type OpenCaseRow = OpenCase & {
+    id: string;
+};
+/**
+ * June (0-based). A SCAR hearing held in Jan–May of calendar year N is leftover work for
+ * tax year N-1; hearings for tax year N start in the summer. Named because it is a
+ * heuristic, not a rule — the picker always lets the user change the year.
+ */
+export declare const TAX_YEAR_ROLLOVER_MONTH = 5;
+export declare function defaultTaxYear(courtDate: Date | string | null | undefined, now?: Date): number;
+/**
+ * Years offered in the picker, newest first, centred on `base` so a wrong guess is one click
+ * to fix. `current` is folded in so a year the user has already navigated to always remains a
+ * valid option for the Select, even once it falls outside the window.
+ */
+export declare function taxYearOptions(base: number, current?: number): number[];
+/**
+ * Matches a case against the search box — owner name, address, index number or parcel,
+ * case-insensitive substring. An empty term matches everything.
+ *
+ * Fields are tested individually rather than joined into one string: joining lets a
+ * multi-word term straddle two fields and match a case it has nothing to do with.
+ */
+export declare function openCaseMatchesSearchTerm(oc: OpenCase, term: string): boolean;
+export declare function openCaseRowId(oc: OpenCase): string;
+/**
+ * Adds grid ids and drops duplicate rows. The endpoint has no DISTINCT and joins Retainers
+ * on (ParcelID, Year), so a parcel with more than one retainer row comes back more than
+ * once — and a duplicate id makes DataGrid throw rather than merely look odd.
+ */
+export declare function toOpenCaseRows(cases: OpenCase[]): OpenCaseRow[];
+/**
+ * Every string by which a case can be recognised as "already here".
+ *
+ * Deliberately keyed on the *index numbers and parcel alone, never the year*: rows the user
+ * typed by hand inherit DEFAULT_CASE.Year (the current calendar year), which will not equal
+ * the tax year they are browsing, so a year-qualified parcel key would never match and the
+ * same property could be added twice.
+ */
+export declare function openCaseDedupeKeys(oc: OpenCase): string[];
+/**
+ * The same keys for a row already in the form. Emits *both* index forms plus the one
+ * `caseIndexForMuni` resolves, so a village case typed in as a county index still matches.
+ */
+export declare function caseDedupeKeys(c: Case, muniCode: string): string[];
+/** True for the empty row CREATE mode seeds, and for any row the user cleared out. */
+export declare function isBlankCaseRow(c: Case): boolean;
+/**
+ * The index this case will be linked under.
+ *
+ * There is only one index field to read: the backend queries the town or village columns
+ * based on the muni code's length and aliases either one to `SCARIndexNumber`. Which *form*
+ * field it lands in on the way back is `openCaseToCase`'s job.
+ */
+export declare function openCaseIndexFor(oc: OpenCase): string;
+/** A row can be checked only if it has a usable index and is not already in the form. */
+export declare function isRowPickable(oc: OpenCase, existingKeys: Set<string>): boolean;
+/**
+ * Normalises the MUI X v8 selection model (`{ type: 'include' | 'exclude', ids: Set }`) into
+ * a plain set of visible, selected ids. `ids` is defensively checked for being a Set — the
+ * same guard CaseViewer makes, since the shape changed between major versions.
+ */
+export declare function resolveSelectedIds(model: {
+    type?: 'include' | 'exclude';
+    ids?: unknown;
+} | null | undefined, visibleIds: string[]): Set<string>;
+/**
+ * A draft Case carrying just enough to be saved and displayed. Municipality and the
+ * determination/valuation fields are left at their defaults on purpose: these rows exist
+ * only to contribute index numbers to the `court_cases` payload, and the calendar refetches
+ * the real cases from the API once the date is saved.
+ */
+export declare function openCaseToCase(oc: OpenCase, isVillage: boolean): Case;
+/**
+ * Adds and removes picked cases in one pass, keeping `toggles` aligned with `cases`.
+ *
+ * This is what makes the two Case-ID modes interchangeable: the checkbox list and the text
+ * fields are two views of the same `editedCases`, so a row checked in one is a field in the
+ * other, and "what have I selected" never needs its own state to drift out of sync.
+ */
+export declare function applyOpenCaseSelection(existingCases: Case[], existingToggles: boolean[], toAdd: OpenCase[], toRemove: OpenCase[], muniCode: string): OpenCaseMergeResult;
+export interface OpenCaseMergeResult {
+    cases: Case[];
+    /** Parcel-ID-mode flags, positionally aligned with `cases`. Always the same length. */
+    toggles: boolean[];
+    added: number;
+    /** Picks already present in the form. */
+    skipped: number;
+    /**
+     * Picks the API returned with no index number. The backend filters these out, so this is
+     * a backstop rather than a path the UI walks — the grid deliberately does not mark such
+     * rows unselectable, because a row already on the date is also "unpickable" and must stay
+     * clickable in order to be unchecked.
+     */
+    unusable: number;
+}
+/**
+ * The single place picked cases are deduplicated and folded into the form's state.
+ *
+ * Returns `toggles` alongside `cases` because the two arrays are positionally coupled in
+ * CreateEditCase and its length-sync effect only fires when the *length* changes — replacing
+ * one blank Parcel-ID-mode row with one picked case would otherwise leave a stale `true`
+ * behind and render the new row's parcel instead of its index.
+ */
+export declare function mergeOpenCases(existingCases: Case[], existingToggles: boolean[], picked: OpenCase[], muniCode: string): OpenCaseMergeResult;