@propriety/court-calendar 1.0.156 → 1.0.157

package/dist/__tests__/CreateEditCaseOpenCases.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/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/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/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/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;