adam/shoc-frontend-new
1
0
Fork 0
mirror of https://github.com/Sea-Haven-Industries/shoc-frontend-new.git synced 2026-09-30 04:33:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

feat(work-orders): send Overdue as its own work order type

Browse source 
Overdue maps to work order type 8 on create, inline correction, board
reads and the type filter, instead of the Other enum and the past-due
flag. It lists the PM service catalog and never sends a severity. Past
Due moves to its own toggle in the advanced filter Status section and
narrows the other filters.
This commit is contained in:
Alexandre Brandizzi 2026-09-25 11:06:21 -03:00
parent 358ec3e890
commit 8a1a12bfa1
17 changed files with 263 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/app/(protected)/workorders/_components/list/advanced-search/adv-filter-sections.tsx
View file

@ -109,7 +109,11 @@ export function AdvancedSearchFilterSections({
/>
</AdvSection>
<AdvSection icon={CheckCircle2} label="Status" count={draft.statuses.size}>
<AdvSection
icon={CheckCircle2}
label="Status"
count={draft.statuses.size + (draft.pastDue ? 1 : 0)}
>
{selectAllRow("statuses", [...ALL_WIZARD_STATUSES], draft.statuses.size)}
<div className="flex flex-wrap gap-1.5">
{ALL_WIZARD_STATUSES.map((status) => (
@ -122,6 +126,14 @@ export function AdvancedSearchFilterSections({
onClick={() => toggleIn("statuses", status)}
/>
))}
<AdvStatusPill
label="Past Due"
dotColor="var(--status-pastdue-text)"
selected={draft.pastDue}
selectedBg="var(--status-pastdue-bg)"
selectedText="var(--status-pastdue-text)"
onClick={() => setDraft((prev) => ({ ...prev, pastDue: !prev.pastDue }))}
/>
</div>
</AdvSection>

6
src/domain/services/api/services-api.ts
View file

@ -20,10 +20,13 @@ const SERVICE_WORK_ORDER_TYPE_API = {
Reactive: 6,
} as const;
const TYPE_TO_API: Record<Exclude<WOType, "Overdue">, number> = {
// The registry is keyed on PM, Reactive and Emergency; Overdue is PM work the
// client never confirmed, so it lists the PM catalog.
const TYPE_TO_API: Record<WOType, number> = {
PM: WORK_ORDER_TYPE_API.PM,
Reactive: WORK_ORDER_TYPE_API.Reactive,
Emergency: WORK_ORDER_TYPE_API.Emergency,
Overdue: WORK_ORDER_TYPE_API.PM,
};
function toApiInput(input: ServiceInput) {
@ -51,7 +54,6 @@ export const servicesApi = {
},
getActiveForWorkOrderType: async (workOrderType: WOType): Promise<Service[]> => {
if (workOrderType === "Overdue") return [];
const data = await apiGet<unknown>(API_PATHS.services.list, {
searchParams: { isActive: true, workOrderType: TYPE_TO_API[workOrderType] },
});

1
src/domain/services/use-cases/use-services-for-work-order-type.ts
View file

@ -11,7 +11,6 @@ export function useServicesForWorkOrderType(
return useQuery({
queryKey: queryKeys.services.byWorkOrderType(effectiveType),
queryFn: () => servicesApi.getActiveForWorkOrderType(effectiveType),
enabled: effectiveType !== "Overdue",
staleTime: 60 * 1000,
});
}

3
src/domain/work-orders/mappers/assign-wizard-service-poc-fields.ts
View file

@ -1,4 +1,5 @@
import type { WorkOrderBoardCreatePayload } from "@/domain/work-orders/types/work-order-board";
import { typeNeedsSeverity } from "@/domain/work-orders/types/work-order-severity";
import type { WorkOrderWizardDraft } from "@/domain/work-orders/types/work-order-wizard";
import { normalizeAdditionalContacts } from "@/domain/work-orders/mappers/additional-contacts-mapper";
@ -64,7 +65,7 @@ export function assignWizardServicePocFields(
payload.vendorNotes = vendorNotes;
}
if (draft.severity != null) {
if (draft.severity != null && typeNeedsSeverity(draft.type)) {
payload.severity = draft.severity;
}

2
src/domain/work-orders/mappers/work-order-board-mapper.ts
View file

@ -28,7 +28,7 @@ const WO_TYPE_TO_API: Record<WOType, WorkOrderTypeApi> = {
Reactive: WORK_ORDER_TYPE_API.Reactive,
Overdue: WORK_ORDER_TYPE_API.Other,
Overdue: WORK_ORDER_TYPE_API.Overdue,
};
/** Leading token of a location label, e.g. `BK5` from `BK5 · Dallas` or `CHI-1042` from `CHI-1042 — Chicago`. */

3
src/domain/work-orders/types/work-order-advanced-filters.ts
View file

@ -35,6 +35,8 @@ export interface WorkOrderAdvancedFilters {
dispatchers: Set<string>;
regions: Set<string>;
statuses: Set<WizardWOStatus>;
/** Past Due overlay (any type); narrows the other filters, independent of the Overdue type. */
pastDue: boolean;
rescheduled: boolean;
carriedOver: boolean;
addOn: boolean;
@ -59,6 +61,7 @@ export const EMPTY_ADVANCED_FILTERS: WorkOrderAdvancedFilters = {
dispatchers: new Set(),
regions: new Set(),
statuses: new Set(),
pastDue: false,
rescheduled: false,
carriedOver: false,
addOn: false,

2
src/domain/work-orders/types/work-order-board.ts
View file

@ -17,6 +17,7 @@ export const WORK_ORDER_TYPE_API = {
Inspection: 5,
Reactive: 6,
AddOn: 7,
Overdue: 8,
Other: 99,
} as const;
@ -64,6 +65,7 @@ export const WORK_ORDER_TYPE_API_TO_FE: Record<number, WOType | ""> = {
[WORK_ORDER_TYPE_API.PM]: "PM",
[WORK_ORDER_TYPE_API.Reactive]: "Reactive",
[WORK_ORDER_TYPE_API.Emergency]: "Emergency",
[WORK_ORDER_TYPE_API.Overdue]: "Overdue",
};
export const LIFECYCLE_STATUS_API_TO_FE: Record<number, WizardWOStatus | "Canceled"> = {

9
src/domain/work-orders/utils/advanced-filter-chip-builders.ts
View file

@ -192,6 +192,15 @@ export function appendStatusPmVendorDocChips(
clear: (current) => ({ ...current, statuses: new Set() }),
});
if (filters.pastDue) {
chips.push({
key: "pastdue",
group: "Status",
value: "Past Due",
clear: (current) => ({ ...current, pastDue: false }),
});
}
pushSetChip({
chips,
key: "pm",

11
src/domain/work-orders/utils/advanced-filter-predicates.ts
View file

@ -45,12 +45,10 @@ const matchesDateRange: AdvancedFilterPredicate = (row, filters) => {
const matchesSite: AdvancedFilterPredicate = (row, filters) =>
!filters.sites.size || filters.sites.has(row.site);
const matchesType: AdvancedFilterPredicate = (row, filters) => {
if (!filters.types.size) return true;
const overdueMatch = filters.types.has("Overdue") && row.isPastDue;
const typeMatch = filters.types.has(row.type as never);
return overdueMatch || typeMatch;
};
const matchesType: AdvancedFilterPredicate = (row, filters) =>
!filters.types.size || filters.types.has(row.type as never);
const matchesPastDue: AdvancedFilterPredicate = (row, filters) => !filters.pastDue || row.isPastDue;
const matchesDispatcher: AdvancedFilterPredicate = (row, filters) => {
if (!filters.dispatchers.size) return true;
@ -95,6 +93,7 @@ export const ADVANCED_FILTER_PREDICATES: AdvancedFilterPredicate[] = [
matchesType,
matchesDispatcher,
matchesStatus,
matchesPastDue,
matchesPmType,
matchesVendorTech,
matchesDoc,

2
src/domain/work-orders/utils/advanced-filters-utils.ts
View file

@ -34,6 +34,7 @@ function cloneFilters(filters: WorkOrderAdvancedFilters): WorkOrderAdvancedFilte
flagColors: new Set(filters.flagColors ?? []),
upliftStatuses: new Set(filters.upliftStatuses ?? []),
unscheduledOnly: Boolean(filters.unscheduledOnly),
pastDue: Boolean(filters.pastDue),
};
}
@ -45,6 +46,7 @@ const ADVANCED_FILTER_ACTIVE_SIGNALS = (filters: WorkOrderAdvancedFilters): bool
Boolean(filters.dispatchers?.size),
Boolean(filters.regions?.size),
Boolean(filters.statuses?.size),
Boolean(filters.pastDue),
filters.rescheduled,
filters.carriedOver,
filters.addOn,

31
src/domain/work-orders/utils/board-query-params.ts
View file

@ -41,30 +41,19 @@ function mapDispatchers(ids: Iterable<string>): string[] | undefined {
return list.length > 0 ? list : undefined;
}
/** Maps UI type filters to API `types` + separate `overdue` flag. Overdue is never sent as types=99. */
function mapWoTypeFilters(types: Iterable<WOType | string>): {
types?: number[];
overdue?: boolean;
} {
/** Maps UI type filters to API `types`. The Overdue type is sent as its own enum; past due uses `overdue`. */
function mapWoTypeFilters(types: Iterable<WOType | string>): number[] | undefined {
const list: number[] = [];
let overdue = false;
for (const type of types) {
if (type === "All") {
continue;
}
if (type === "Overdue") {
overdue = true;
continue;
}
const api = mapWizardTypeToApi(type as WOType);
if (api != null) {
list.push(api);
}
}
return {
types: list.length > 0 ? list : undefined,
overdue: overdue || undefined,
};
return list.length > 0 ? list : undefined;
}
function mapStatuses(statuses: Iterable<WizardWOStatus | string>): number[] | undefined {
@ -139,14 +128,11 @@ export function toBoardQueryParams(
search: string,
): WorkOrderBoardQueryParams {
const [, weekTo] = weekRange(bar.weekMonday);
const typeFilters = bar.types.size > 0 ? mapWoTypeFilters(bar.types) : {};
return {
weekStart: bar.weekMonday,
weekEnd: weekTo,
dispatchers: mapDispatchers(bar.dispatcherIds),
types: typeFilters.types,
overdue: typeFilters.overdue,
types: mapWoTypeFilters(bar.types),
search: search.trim().length >= 2 ? search.trim() : undefined,
};
}
@ -203,7 +189,6 @@ export function toBoardSearchQueryParams(input: {
BOARD_SEARCH_MAX_PAGE_SIZE,
);
const typeFilters = mapWoTypeFilters(filters.types);
const trimmedSearch = input.search?.trim();
const search = trimmedSearch && trimmedSearch.length >= 2 ? trimmedSearch : undefined;
@ -216,8 +201,8 @@ export function toBoardSearchQueryParams(input: {
dateTo: date.dateTo,
includeDateless: date.includeDateless,
sites: filters.sites.size > 0 ? [...filters.sites] : undefined,
types: typeFilters.types,
overdue: typeFilters.overdue,
types: mapWoTypeFilters(filters.types),
overdue: filters.pastDue || undefined,
dispatchers: mapDispatchers(filters.dispatchers),
regions: filters.regions.size > 0 ? [...filters.regions] : undefined,
statuses: mapStatuses(filters.statuses),
@ -252,10 +237,6 @@ export function buildBoardSearchParamsRecord(
return out;
}
export function woTypeFilterIsOverdue(type: string): boolean {
return type === "Overdue";
}
/** Week-independent GET /board/search params for the pinned Unassigned queue. */
export function toUnassignedQueueQueryParams(
page = 0,

7
src/domain/work-orders/utils/table-filter-utils.ts
View file

@ -65,12 +65,7 @@ function rowMatchesSearch(row: WorkOrderTableRow, query: string): boolean {
}
function rowMatchesBarTypes(row: WorkOrderTableRow, types: Set<WOType>): boolean {
if (types.size === 0) {
return true;
}
const overdueMatch = types.has("Overdue") && row.isPastDue;
const typeMatch = types.has(row.type as WOType);
return overdueMatch || typeMatch;
return types.size === 0 || types.has(row.type as WOType);
}
export function filterByBarAndSearch(

154
src/test/app/(protected)/workorders/overdue-work-order-type.test.tsx Normal file
View file

@ -0,0 +1,154 @@
import { fireEvent, render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { describe, expect, it, vi } from "vitest";
import { SlideOverCompletionTab } from "@/app/(protected)/workorders/_components/detail/tabs/slide-over-completion-tab";
import { AdvancedSearchFilterSections } from "@/app/(protected)/workorders/_components/list/advanced-search/adv-filter-sections";
import { TypeCell } from "@/app/(protected)/workorders/_components/list/table/cells/type-cell";
import { WizardStepTypeSchedule } from "@/app/(protected)/workorders/_components/wizard/wizard-step-type-schedule";
import { mapWorkOrderTableRow } from "@/domain/work-orders/mappers/work-order-table-row-mapper";
import { mapWizardDraftToBoardCreatePayload } from "@/domain/work-orders/mappers/work-order-board-mapper";
import {
EMPTY_ADVANCED_FILTERS,
type WorkOrderAdvancedFilters,
} from "@/domain/work-orders/types/work-order-advanced-filters";
import { WORK_ORDER_TYPE_API } from "@/domain/work-orders/types/work-order-board";
import type { WorkOrderTableRow } from "@/domain/work-orders/types/work-order-table-row";
import {
canContinueWizardStep1,
EMPTY_WIZARD_DRAFT,
type WorkOrderWizardDraft,
} from "@/domain/work-orders/types/work-order-wizard";
import { buildAdvancedFilterChips } from "@/domain/work-orders/utils/advanced-filters-utils";
import { getClosabilityGaps } from "@/domain/work-orders/utils/wo-closability";
const USERS = [{ id: "sarah", name: "Sarah Chen" }];
describe("Overdue work order type", () => {
it("offers Overdue in the Create WO wizard and never asks for a severity", () => {
const onPatch = vi.fn();
const { rerender } = render(
<WizardStepTypeSchedule
draft={{ ...EMPTY_WIZARD_DRAFT, type: "PM" }}
users={USERS}
onUpdate={vi.fn()}
onPatch={onPatch}
/>,
);
fireEvent.click(screen.getByRole("button", { name: /No client response — due date passed/ }));
expect(onPatch).toHaveBeenCalledWith(
expect.objectContaining({ type: "Overdue", severity: null }),
);
const overdueDraft: WorkOrderWizardDraft = { ...EMPTY_WIZARD_DRAFT, type: "Overdue" };
rerender(
<WizardStepTypeSchedule
draft={overdueDraft}
users={USERS}
onUpdate={vi.fn()}
onPatch={onPatch}
/>,
);
expect(screen.queryByText(/Severity \(from APM\)/)).not.toBeInTheDocument();
expect(canContinueWizardStep1(overdueDraft)).toBe(true);
});
it("creates the work order with the Overdue enum and no severity", () => {
const payload = mapWizardDraftToBoardCreatePayload({
...EMPTY_WIZARD_DRAFT,
type: "Overdue",
severity: 2,
locationId: "1",
siteCode: "BK5",
});
expect(payload.workOrderType).toBe(WORK_ORDER_TYPE_API.Overdue);
expect(payload.severity ?? null).toBeNull();
});
it("corrects a type inline to Overdue without opening the severity dialog", async () => {
const onSave = vi.fn();
const user = userEvent.setup();
render(<TypeCell value="Reactive" severity={3} onSave={onSave} />);
await user.click(screen.getByRole("button", { name: "Type of WO, Reactive" }));
await user.click(screen.getByRole("button", { name: /^Overdue$/ }));
expect(onSave).toHaveBeenCalledWith("Overdue", null);
expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
});
it("reads the Overdue enum back from the board as the Overdue type", () => {
const row = mapWorkOrderTableRow({ id: 1, workOrderType: WORK_ORDER_TYPE_API.Overdue });
expect(row.type).toBe("Overdue");
});
it("closes with the completion document, not photos", () => {
const base = {
id: "1",
dispatcherId: "sarah",
dispatcherName: "Sarah Chen",
company: "Gateway Plumbing",
vendorId: "",
tech: "",
completedDate: "2026-09-24",
woNumber: "24971",
pm: "Backflow Preventers",
mediaCount: 0,
};
expect(
getClosabilityGaps({ ...base, type: "Overdue" as const, docStatus: "No" as const }),
).toEqual(["Completion document"]);
expect(
getClosabilityGaps({ ...base, type: "Overdue" as const, docStatus: "Yes" as const }),
).toEqual([]);
const row = {
id: "1",
type: "Overdue",
pm: "Backflow Preventers",
docStatus: "No",
rowVersion: "1",
};
render(
<SlideOverCompletionTab
row={row as WorkOrderTableRow}
isReadOnly={false}
media={[]}
onOpenCompletionDoc={vi.fn()}
/>,
);
expect(screen.getByText("Completion Document")).toBeInTheDocument();
expect(screen.getByRole("button", { name: /open completion document/i })).toBeEnabled();
});
it("keeps a separate Past Due status toggle in the advanced filters", () => {
let draft: WorkOrderAdvancedFilters = { ...EMPTY_ADVANCED_FILTERS };
const setDraft = vi.fn(
(update: (prev: WorkOrderAdvancedFilters) => WorkOrderAdvancedFilters) => {
draft = update(draft);
},
);
render(
<AdvancedSearchFilterSections
draft={draft}
setDraft={setDraft as never}
toggleIn={vi.fn()}
setMany={vi.fn()}
sites={[]}
users={[]}
pmTypes={[]}
vendorTechs={[]}
/>,
);
fireEvent.click(screen.getByRole("button", { name: /^Status/ }));
fireEvent.click(screen.getByRole("button", { name: /Past Due/ }));
expect(draft.pastDue).toBe(true);
expect(draft.types.size).toBe(0);
expect(buildAdvancedFilterChips(draft)).toContainEqual(
expect.objectContaining({ group: "Status", value: "Past Due" }),
);
});
});

11
src/test/domain/services/api/services-api.test.ts
View file

@ -78,11 +78,14 @@ describe("servicesApi", () => {
});
});
it("does not request services for the unsupported Overdue type", async () => {
const services = await servicesApi.getActiveForWorkOrderType("Overdue");
it("lists the PM catalog for the Overdue type", async () => {
vi.mocked(apiGet).mockResolvedValue([]);
expect(apiGet).not.toHaveBeenCalled();
expect(services).toEqual([]);
await servicesApi.getActiveForWorkOrderType("Overdue");
expect(apiGet).toHaveBeenCalledWith(API_PATHS.services.list, {
searchParams: { isActive: true, workOrderType: 2 },
});
});
it("creates, updates, and deactivates through the registry routes", async () => {

4
src/test/domain/work-orders/mappers/work-order-board-mapper.test.ts
View file

@ -36,7 +36,9 @@ describe("mapWizardTypeToApi", () => {
expect(mapWizardTypeToApi("Reactive")).toBe(WORK_ORDER_TYPE_API.Reactive);
expect(mapWizardTypeToApi("Overdue")).toBe(WORK_ORDER_TYPE_API.Other);
expect(mapWizardTypeToApi("Overdue")).toBe(WORK_ORDER_TYPE_API.Overdue);
expect(WORK_ORDER_TYPE_API.Overdue).toBe(8);
expect(mapWizardTypeToApi("")).toBeNull();
});

23
src/test/domain/work-orders/utils/board-query-params.test.ts
View file

@ -60,16 +60,16 @@ describe("toBoardQueryParams", () => {
expect(params.overdue).toBeUndefined();
});
it("maps Overdue bar filter to overdue=true without types", () => {
it("maps the Overdue bar filter to the Overdue type, not the past-due flag", () => {
const params = toBoardQueryParams({ ...baseBar, types: new Set(["Overdue"]) }, "");
expect(params.overdue).toBe(true);
expect(params.types).toBeUndefined();
expect(params.types).toEqual([WORK_ORDER_TYPE_API.Overdue]);
expect(params.overdue).toBeUndefined();
});
it("maps Overdue with real types as OR (types + overdue)", () => {
it("maps Overdue with other types as a plain type union", () => {
const params = toBoardQueryParams({ ...baseBar, types: new Set(["PM", "Overdue"]) }, "");
expect(params.types).toEqual([WORK_ORDER_TYPE_API.PM]);
expect(params.overdue).toBe(true);
expect(params.types).toEqual([WORK_ORDER_TYPE_API.PM, WORK_ORDER_TYPE_API.Overdue]);
expect(params.overdue).toBeUndefined();
});
it("omits types when the set is empty", () => {
@ -222,22 +222,23 @@ describe("toBoardSearchQueryParams", () => {
expect(buildBoardSearchParamsRecord(params)).not.toHaveProperty("unscheduledOnly");
});
it("maps Overdue-only advanced filter to overdue=true without types", () => {
it("maps the Overdue type advanced filter to types without the past-due flag", () => {
const params = toBoardSearchQueryParams({
filters: {
...EMPTY_ADVANCED_FILTERS,
types: new Set(["Overdue"]),
},
});
expect(params.overdue).toBe(true);
expect(params.types).toBeUndefined();
expect(params.types).toEqual([WORK_ORDER_TYPE_API.Overdue]);
expect(params.overdue).toBeUndefined();
});
it("maps Overdue with real types as OR (types + overdue)", () => {
it("maps the Past Due status toggle to overdue=true alongside types", () => {
const params = toBoardSearchQueryParams({
filters: {
...EMPTY_ADVANCED_FILTERS,
types: new Set(["PM", "Overdue"]),
types: new Set(["PM"]),
pastDue: true,
},
});
expect(params.types).toEqual([WORK_ORDER_TYPE_API.PM]);

53
src/test/domain/work-orders/utils/table-filter-utils.test.ts
View file

@ -172,26 +172,26 @@ describe("filterByBarAndSearch", () => {
expect(ids).toEqual(["em", "rx"]);
});
it("matches Overdue via isPastDue even when row.type is not Overdue", () => {
it("matches the Overdue type only, never a past-due row of another type", () => {
const pastDuePm = makeRow({
id: "pd",
type: "PM",
isPastDue: true,
scheduledOn: "2026-06-03",
});
const currentPm = makeRow({
id: "now",
type: "PM",
const overdue = makeRow({
id: "ov",
type: "Overdue",
isPastDue: false,
scheduledOn: "2026-06-03",
});
const ids = filterByBarAndSearch(
[pastDuePm, currentPm],
[pastDuePm, overdue],
bar(weekMonday, { types: new Set(["Overdue"]) }),
"",
).map((row) => row.id);
expect(ids).toEqual(["pd"]);
expect(ids).toEqual(["ov"]);
});
it("hides a row after type correction when the bar filter no longer matches", () => {
@ -395,13 +395,8 @@ describe("matchesAdvancedFilters", () => {
expect(matchesAdvancedFilters(row, noMatch)).toBe(false);
});
it("matches Overdue when isPastDue is true", () => {
it("matches the Overdue type filter by type, independent of isPastDue", () => {
const weekMonday = mondayOf(todayIso());
const pastDue = makeRow({
scheduledOn: weekMonday,
...deriveDayFields(weekMonday),
isPastDue: true,
});
const filters = {
...EMPTY_ADVANCED_FILTERS,
dateRange: "custom" as const,
@ -409,9 +404,39 @@ describe("matchesAdvancedFilters", () => {
customTo: "9999-12-31",
types: new Set(["Overdue" as const]),
};
expect(matchesAdvancedFilters(pastDue, filters)).toBe(true);
const overdue = makeRow({ type: "Overdue", isPastDue: false, scheduledOn: weekMonday });
const pastDuePm = makeRow({ type: "PM", isPastDue: true, scheduledOn: weekMonday });
expect(matchesAdvancedFilters(overdue, filters)).toBe(true);
expect(matchesAdvancedFilters(pastDuePm, filters)).toBe(false);
});
it("narrows to past-due rows with the Past Due status toggle", () => {
const weekMonday = mondayOf(todayIso());
const filters = {
...EMPTY_ADVANCED_FILTERS,
dateRange: "custom" as const,
customFrom: "0000-01-01",
customTo: "9999-12-31",
types: new Set(["PM" as const]),
pastDue: true,
};
expect(
matchesAdvancedFilters(makeRow({ isPastDue: false, scheduledOn: weekMonday }), filters),
matchesAdvancedFilters(
makeRow({ type: "PM", isPastDue: true, scheduledOn: weekMonday }),
filters,
),
).toBe(true);
expect(
matchesAdvancedFilters(
makeRow({ type: "PM", isPastDue: false, scheduledOn: weekMonday }),
filters,
),
).toBe(false);
expect(
matchesAdvancedFilters(
makeRow({ type: "Overdue", isPastDue: true, scheduledOn: weekMonday }),
filters,
),
).toBe(false);
});