@propriety/court-calendar 1.0.156 → 1.0.158

package/.vscode/extensions.json

@@ -0,0 +1,108 @@
+{
+  // Stack for this repo: React 19 + TypeScript + Vite (library mode) + Biome + Vitest + MUI 5.
+  // NOTE: "unwantedRecommendations" only suppresses VS Code's recommendation prompts.
+  // It does NOT disable an installed extension. To actually disable, either:
+  //   a) Extensions view -> right-click -> "Disable (Workspace)", or
+  //   b) import the profile at .vscode/court-calendar.code-profile (see README note below).
+  "recommendations": [
+    "biomejs.biome",
+    "yoavbls.pretty-ts-errors",
+    "antfu.vite",
+    "christian-kohler.path-intellisense",
+    "christian-kohler.npm-intellisense",
+    "eamodio.gitlens",
+    "github.vscode-pull-request-github"
+  ],
+
+  "unwantedRecommendations": [
+    // --- Formatter/linter conflicts: this repo uses Biome exclusively ---
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint",
+    "inferrinizzard.prettier-sql-vscode",
+
+    // --- Python stack (lives in ../adminAPI, ../Utility-API, ../pdfOcr) ---
+    "ms-python.python",
+    "ms-python.vscode-pylance",
+    "ms-python.debugpy",
+    "ms-python.black-formatter",
+    "ms-python.isort",
+    "ms-python.vscode-python-envs",
+    "charliermarsh.ruff",
+    "kevinrose.vsc-python-indent",
+
+    // --- Jupyter ---
+    "ms-toolsai.jupyter",
+    "ms-toolsai.jupyter-renderers",
+    "ms-toolsai.jupyter-keymap",
+    "ms-toolsai.vscode-jupyter-cell-tags",
+    "ms-toolsai.vscode-jupyter-slideshow",
+
+    // --- .NET / C# ---
+    "ms-dotnettools.csharp",
+    "ms-dotnettools.csdevkit",
+    "ms-dotnettools.vscode-dotnet-runtime",
+
+    // --- C / C++ / shaders ---
+    "ms-vscode.cpptools",
+    "jbenden.c-cpp-flylint",
+    "slevesque.shader",
+
+    // --- AutoHotkey (three overlapping extensions) ---
+    "cweijan.vscode-autohotkey-plus",
+    "mark-wiemer.vscode-autohotkey-plus-plus",
+    "thqby.vscode-autohotkey2-lsp",
+
+    // --- Other frameworks not used here (MUI + Emotion, no Tailwind/Vue/Sass) ---
+    "vue.volar",
+    "bradlc.vscode-tailwindcss",
+    "austenc.tailwind-docs",
+    "syler.sass-indented",
+    "glenn2223.live-sass",
+
+    // --- AWS / containers (belongs to ../lambdas) ---
+    "amazonwebservices.aws-toolkit-vscode",
+    "ms-azuretools.vscode-containers",
+    "ms-vscode-remote.remote-containers",
+
+    // --- Static/live servers: superseded by `npm run dev` (Vite) ---
+    "ritwickdey.liveserver",
+    "ms-vscode.live-server",
+    "george-alisson.html-preview-vscode",
+    "antfu.browse-lite",
+
+    // --- Redundant with built-in editor features (see .vscode/settings.json) ---
+    "formulahendry.auto-rename-tag",
+    "formulahendry.auto-close-tag",
+    "steoates.autoimport",
+    "kevinmcgowan.typescriptimport",
+    "donjayamanne.githistory",
+    "xyz.local-history",
+
+    // --- Continuous-CPU novelty extensions ---
+    "tonybaloney.vscode-pets",
+    "hoovercj.vscode-power-mode",
+
+    // --- Heavy eager extensions with no role in this repo ---
+    "shd101wyy.markdown-preview-enhanced",
+    "zignd.html-css-class-completion",
+    "ecmel.vscode-html-css",
+    "hwencc.html-tag-wrapper",
+    "kisstkondoros.vscode-gutter-preview",
+    "alefragnani.project-manager",
+    "ms-vsliveshare.vsliveshare",
+    "tamasfe.even-better-toml",
+
+    // --- Data/document viewers ---
+    "grapecity.gc-excelviewer",
+    "muhammad-ahmad.xlsx-viewer",
+    "mechatroner.rainbow-csv",
+    "tomoki1207.pdf",
+
+    // --- Misc unused languages ---
+    "eww-yuck.yuck",
+    "andrejunges.handlebars",
+    "mrmlnc.vscode-json5",
+    "idered.npm",
+    "petekinnecom.terminal-command-keys"
+  ]
+}

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

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

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

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

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/api/apiFailures.test.d.ts

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

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

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

package/dist/_components/ErrorReport/ApiFailureReporter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The single place a failed API call becomes visible.
+ *
+ * Deliberately **persistent** — no `autoHideDuration`. A four-second toast is how a failed
+ * delete went unnoticed in the first place; an error the user needs to report has to wait for
+ * them. Anchored top-center so it never collides with the transient bottom-center snackbars
+ * (saved / hidden-by-filter / bootstrap) that the calendar already uses.
+ *
+ * Mount once, high in the tree. It subscribes to the module-level failure bus in
+ * `helpers/api/apiFailures`, so it needs no props from the call sites that fail.
+ */
+export default function ApiFailureReporter({ activeUser }: {
+    activeUser?: number;
+}): import("react/jsx-runtime").JSX.Element | null;

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

@@ -0,0 +1,13 @@
+/**
+ * Click-to-copy chip used for the identity fields on the Case Details panel
+ * (parcel ID, SCAR index number). Each instance owns its own "Copied!" state so
+ * copying one field never flips the tooltip on another.
+ *
+ * Renders as a `span` by default: `InfoField` wraps its value in a `Typography`
+ * (a `<p>`), and a `div` inside a `<p>` is invalid nesting.
+ */
+export default function CopyChip({ value, size, component, }: {
+    value: string;
+    size?: 'small' | 'medium';
+    component?: React.ElementType;
+}): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,68 @@
+/**
+ * A cross-cutting sink for API failures, so a request the server rejected always reaches the
+ * screen instead of only the console.
+ *
+ * Every helper in this folder reports failure by returning `false`/`null` and writing a
+ * `console.error` — which is why a delete the server refused looked identical to one that
+ * worked. Rather than change each helper's signature (and every call site, and every
+ * `.then(ok => …)` that depends on the boolean), each failing branch now *also* publishes an
+ * `ApiFailure` here. `ApiFailureReporter` subscribes on mount and renders whatever arrives.
+ *
+ * A module-level bus rather than React context because these fire from plain async functions
+ * that have no access to a provider — the same reason crash reporters are built this way.
+ *
+ * NOTE: nothing published here may contain the API key. The report is written to be pasted
+ * into a chat or ticket, so it carries the request *shape* (method, URL, status, response
+ * body) but never a credential.
+ */
+export interface ApiFailure {
+    /** What the user was trying to do, in their words: "Delete court date". */
+    operation: string;
+    /** Which record it was, e.g. "#1234 (Negotiations)". */
+    subject?: string;
+    method?: string;
+    url?: string;
+    /** `null` when the request never reached the server — offline, DNS, CORS, or a timeout. */
+    status: number | null;
+    /** One-line plain-English cause, shown to the user. */
+    detail: string;
+    /** Raw response body (or the thrown error's message), truncated. For the tech team. */
+    body?: string;
+    at: Date;
+}
+type Listener = (failure: ApiFailure) => void;
+/** Subscribe to API failures. Returns an unsubscribe function suitable for a `useEffect`. */
+export declare function onApiFailure(listener: Listener): () => void;
+/** Publish a failure to every subscriber. A throwing listener must not break the others. */
+export declare function publishApiFailure(failure: ApiFailure): void;
+/** Log and publish a non-2xx response. */
+export declare function reportHttpFailure(operation: string, method: string, url: string, res: Response, subject?: string): Promise<void>;
+/**
+ * Log and publish a request that never completed.
+ *
+ * `fetch` *rejects* rather than resolving with `ok: false` when the browser cannot reach the
+ * server at all — offline, DNS failure, a CORS preflight refusal, a dropped connection. Those
+ * used to escape as unhandled promise rejections from a click handler: no console error, no UI.
+ */
+export declare function reportNetworkFailure(operation: string, method: string, url: string, error: unknown, subject?: string): void;
+/**
+ * Publish an application-level problem that is not a single failed request — a partially
+ * applied save, for example, where each individual call succeeded or was already reported.
+ */
+export declare function reportProblem(problem: {
+    operation: string;
+    subject?: string;
+    detail: string;
+    body?: string;
+}): void;
+/**
+ * The copy-paste block handed to the tech team.
+ *
+ * Written for a chat message or ticket: fixed-width, no markdown, and self-contained — whoever
+ * receives it should not have to ask "which record?", "what time?", or "what did the server
+ * actually say?". Carries no API key (see the file header).
+ */
+export declare function formatFailureReport(failures: ApiFailure[], context?: {
+    activeUser?: number;
+}): string;
+export {};

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

@@ -0,0 +1,9 @@
+/**
+ * Copy text to the clipboard, reporting honestly whether it worked.
+ *
+ * `navigator.clipboard` is unavailable on insecure origins and *rejects* when the document
+ * isn't focused or the permission was denied — so a bare `writeText()` can silently leave the
+ * clipboard empty while the UI says "Copied". Both paths are tried and the caller is told
+ * which happened, so a failure can fall back to showing the text for manual selection.
+ */
+export declare function copyText(text: 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;

package/dist/hooks/UseModalActions.d.ts

@@ -17,7 +17,8 @@ import { ModalMode } from '../_components/Modal/types';
  *
  * @returns
  * - `handleSave`                        – Validates and persists the edited court date (creates or updates).
- * - `handleDelete`                      – Confirms, then deletes the selected court date.
+ * - `handleDelete`                      – Confirms, then deletes the selected court date. Returns
+ *                                        false and leaves local state untouched if the server refused.
  * - `handleViewUpdateChair`             – Optimistically updates a first/second chair in view mode.
  * - `handleSelectedCasesAdjournmentChange` – Adjourns a set of cases (sets AdjournedDate + `OA` determination), then reconciles with the server.
  * - `handleSelectedCasesClearDetermination` – Clears the determination for a set of cases (backend only clears `D`), then reconciles with the server.
@@ -33,7 +34,7 @@ export declare function useModalActions({ modalMode, selectedCourtDate, selected
     pendingNoticeFiles?: File[];
 }): {
     handleSave: () => Promise<boolean>;
-    handleDelete: () => Promise<void>;
+    handleDelete: () => Promise<boolean>;
     handleViewUpdateChair: (position: "first" | "second", userId: number | null) => void;
     handleSelectedCasesAdjournmentChange: (casesToUpdate: Case[], date: Date | null) => Promise<boolean>;
     handleSelectedCasesClearDetermination: (casesToUpdate: Case[]) => Promise<boolean>;