@terreno/ui 0.13.3 → 0.14.1

package/src/DataTable.test.tsx

@@ -1,4 +1,6 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {describe, expect, it, mock} from "bun:test";
+import {act} from "@testing-library/react-native";
 
 import {DataTable} from "./DataTable";
 import {Text} from "./Text";
@@ -130,4 +132,220 @@ describe("DataTable", () => {
     const {toJSON} = renderWithTheme(<DataTable columns={sampleColumns} data={[]} />);
     expect(toJSON()).toMatchSnapshot();
   });
+
+  it("handles sort cycling: none -> asc -> desc -> none", () => {
+    const sortableColumns = [
+      {columnType: "text", sortable: true, title: "Name", width: 150},
+      {columnType: "text", sortable: false, title: "Age", width: 100},
+    ];
+    const setSortColumn = mock((_sort?: {column: number; direction: string}) => {});
+    const {UNSAFE_getAllByType} = renderWithTheme(
+      <DataTable
+        columns={sortableColumns}
+        data={[[{value: "Alice"}, {value: "28"}]]}
+        setSortColumn={setSortColumn}
+      />
+    );
+
+    const {Pressable: PressableComp} = require("react-native");
+    const pressables = UNSAFE_getAllByType(PressableComp);
+    // Find the sort pressable (has hitSlop=16)
+    const sortPressable = pressables.find(
+      (p: {props: {hitSlop?: number}}) => p.props.hitSlop === 16
+    );
+    expect(sortPressable).toBeTruthy();
+
+    const {fireEvent} = require("@testing-library/react-native");
+    // First click: none -> asc
+    fireEvent.press(sortPressable!);
+    expect(setSortColumn).toHaveBeenCalledWith({column: 0, direction: "asc"});
+  });
+
+  it("handles sort from asc to desc", () => {
+    const sortableColumns = [{columnType: "text", sortable: true, title: "Name", width: 150}];
+    const setSortColumn = mock((_sort?: {column: number; direction: string}) => {});
+    const {UNSAFE_getAllByType} = renderWithTheme(
+      <DataTable
+        columns={sortableColumns}
+        data={[[{value: "Alice"}]]}
+        setSortColumn={setSortColumn}
+        sortColumn={{column: 0, direction: "asc"}}
+      />
+    );
+
+    const {Pressable: PressableComp} = require("react-native");
+    const pressables = UNSAFE_getAllByType(PressableComp);
+    const sortPressable = pressables.find(
+      (p: {props: {hitSlop?: number}}) => p.props.hitSlop === 16
+    );
+
+    const {fireEvent} = require("@testing-library/react-native");
+    fireEvent.press(sortPressable!);
+    expect(setSortColumn).toHaveBeenCalledWith({column: 0, direction: "desc"});
+  });
+
+  it("handles sort from desc to none", () => {
+    const sortableColumns = [{columnType: "text", sortable: true, title: "Name", width: 150}];
+    const setSortColumn = mock((_sort?: {column: number; direction: string}) => {});
+    const {UNSAFE_getAllByType} = renderWithTheme(
+      <DataTable
+        columns={sortableColumns}
+        data={[[{value: "Alice"}]]}
+        setSortColumn={setSortColumn}
+        sortColumn={{column: 0, direction: "desc"}}
+      />
+    );
+
+    const {Pressable: PressableComp} = require("react-native");
+    const pressables = UNSAFE_getAllByType(PressableComp);
+    const sortPressable = pressables.find(
+      (p: {props: {hitSlop?: number}}) => p.props.hitSlop === 16
+    );
+
+    const {fireEvent} = require("@testing-library/react-native");
+    fireEvent.press(sortPressable!);
+    expect(setSortColumn).toHaveBeenCalledWith(undefined);
+  });
+
+  it("handles sort on non-sortable column (no-op)", () => {
+    const columns = [{columnType: "text", sortable: false, title: "Name", width: 150}];
+    const setSortColumn = mock(() => {});
+    renderWithTheme(
+      <DataTable columns={columns} data={[[{value: "Alice"}]]} setSortColumn={setSortColumn} />
+    );
+    // No sort pressable rendered for non-sortable columns, so no action needed
+    expect(setSortColumn).not.toHaveBeenCalled();
+  });
+
+  it("syncs scroll between header and body via refs", () => {
+    const {UNSAFE_getAllByType} = renderWithTheme(
+      <DataTable columns={sampleColumns} data={sampleData} pinnedColumns={1} />
+    );
+
+    const {ScrollView: ScrollViewComp} = require("react-native");
+    const scrollViews = UNSAFE_getAllByType(ScrollViewComp);
+    expect(scrollViews.length).toBeGreaterThan(0);
+
+    // Inject mock scrollTo on the refs so handleScroll branches execute
+    const mockScrollTo = mock((_opts: {animated: boolean; x: number}) => {});
+    for (const sv of scrollViews) {
+      if (sv.props.horizontal) {
+        const fiber = (sv as unknown as {_fiber?: {ref?: {current: unknown}}})._fiber;
+        if (fiber?.ref && typeof fiber.ref === "object") {
+          fiber.ref.current = {scrollTo: mockScrollTo};
+        }
+      }
+    }
+
+    const {fireEvent} = require("@testing-library/react-native");
+    // Find header scroll (onScroll passes isHeader=true)
+    const headerScroll = scrollViews.find(
+      (sv: {props: {horizontal?: boolean; showsHorizontalScrollIndicator?: boolean}}) =>
+        sv.props.horizontal && sv.props.showsHorizontalScrollIndicator === false
+    );
+    // Find body scroll (onScroll passes isHeader=false)
+    const bodyScroll = scrollViews.find(
+      (sv: {props: {horizontal?: boolean; showsHorizontalScrollIndicator?: boolean}}) =>
+        sv.props.horizontal && sv.props.showsHorizontalScrollIndicator === true
+    );
+
+    if (headerScroll) {
+      fireEvent.scroll(headerScroll, {
+        nativeEvent: {contentOffset: {x: 50, y: 0}},
+      });
+    }
+    if (bodyScroll) {
+      fireEvent.scroll(bodyScroll, {
+        nativeEvent: {contentOffset: {x: 75, y: 0}},
+      });
+    }
+
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  it("renders with custom column component map", () => {
+    const CustomComponent = ({cellData}: {cellData: {value: unknown}}) => (
+      <Text>Custom: {String(cellData.value)}</Text>
+    );
+    const customColumns = [{columnType: "custom", title: "Custom Col", width: 150}];
+    const customData = [[{value: "test"}]];
+    const {getByText} = renderWithTheme(
+      <DataTable
+        columns={customColumns}
+        customColumnComponentMap={{custom: CustomComponent as any}}
+        data={customData}
+      />
+    );
+    expect(getByText("Custom: test")).toBeTruthy();
+  });
+
+  it("renders with infoModalText on column header", () => {
+    const columnsWithInfo = [
+      {columnType: "text", infoModalText: "**Help text**", title: "Name", width: 150},
+    ];
+    const {toJSON} = renderWithTheme(
+      <DataTable columns={columnsWithInfo} data={[[{value: "Alice"}]]} />
+    );
+    expect(toJSON()).toBeTruthy();
+  });
+
+  it("renders with cell highlight", () => {
+    const highlightData = [[{highlight: "primary", value: "Highlighted"}]];
+    const {toJSON} = renderWithTheme(
+      <DataTable columns={[{columnType: "text", title: "Name", width: 150}]} data={highlightData} />
+    );
+    expect(toJSON()).toBeTruthy();
+  });
+
+  it("renders with moreContentExtraData", () => {
+    const MoreContent = ({rowIndex, extraInfo}: {rowIndex: number; extraInfo?: string}) => (
+      <Text>
+        Row {rowIndex}: {extraInfo}
+      </Text>
+    );
+    const {toJSON} = renderWithTheme(
+      <DataTable
+        columns={sampleColumns}
+        data={sampleData}
+        moreContentComponent={MoreContent as any}
+        moreContentExtraData={[{extraInfo: "info1"}, {extraInfo: "info2"}, {extraInfo: "info3"}]}
+      />
+    );
+    expect(toJSON()).toBeTruthy();
+  });
+
+  it("opens and dismisses more content modal via MoreButtonCell press", async () => {
+    const MoreContent = ({rowIndex}: {rowIndex: number}) => <Text>Detail for row {rowIndex}</Text>;
+    const {UNSAFE_getAllByType} = renderWithTheme(
+      <DataTable
+        columns={sampleColumns}
+        data={sampleData}
+        moreContentComponent={MoreContent as any}
+      />
+    );
+
+    const {Pressable: PressableComp} = require("react-native");
+    const {fireEvent} = require("@testing-library/react-native");
+    const pressables = UNSAFE_getAllByType(PressableComp);
+
+    // Find the info/eye icon pressable (MoreButtonCell has accessibilityHint="View details")
+    const moreBtn = pressables.find(
+      (p: {props: {accessibilityHint?: string}}) => p.props.accessibilityHint === "View details"
+    );
+    expect(moreBtn).toBeTruthy();
+
+    // Press to open modal
+    await act(async () => {
+      fireEvent.press(moreBtn!);
+    });
+
+    // Find the modal dismiss pressable and press it
+    const {Modal: ModalComp} = require("./Modal");
+    const modals = UNSAFE_getAllByType(ModalComp);
+    if (modals.length > 0 && modals[0].props.onDismiss) {
+      await act(async () => {
+        modals[0].props.onDismiss();
+      });
+    }
+  });
 });

package/src/DataTable.tsx

@@ -264,7 +264,7 @@ const DataTableHeaderCell: FC<DataTableHeaderCellProps> = ({
       }}
     >
       {[
-        Boolean(column.title) ? (
+        column.title ? (
           <TableTitle align="left" key="data-table-header-title" title={column.title!} />
         ) : null,
         <View key="data-table-header-tools" style={{alignItems: "center", flexDirection: "row"}}>

package/src/DateTimeActionSheet.tsx

@@ -369,7 +369,11 @@ const DateCalendar = ({
   const {theme} = useTheme();
 
   const markedDates: {
-    [id: string]: {selected: boolean; selectedColor: string; customStyles?: any};
+    [id: string]: {
+      selected: boolean;
+      selectedColor: string;
+      customStyles?: {container?: {backgroundColor?: string; borderRadius?: number}};
+    };
   } = {};
 
   // Check if the date is T00:00:00.000Z (it should be), otherwise treat it as a date in the
@@ -471,7 +475,7 @@ export const DateTimeActionSheet = ({
 
   // If the value changes in the props, update the state for the date and time.
   useEffect(() => {
-    let datetime;
+    let datetime: DateTime;
     if (value) {
       if (type === "date") {
         datetime = DateTime.fromISO(value).toUTC().set({millisecond: 0, second: 0});
@@ -495,7 +499,7 @@ export const DateTimeActionSheet = ({
     setHour(h);
     setMinute(datetime.minute);
     setAmPm(datetime.toFormat("a") === "AM" ? "am" : "pm");
-    setDate(datetime.toISO());
+    setDate(datetime.toISO() ?? "");
     // Reset timezone when the sent date changes.
     setTimezone(originalTimezone);
   }, [value, originalTimezone, type]);

package/src/DateTimeField.test.tsx

@@ -1,3 +1,4 @@
+// biome-ignore-all lint/suspicious/noExplicitAny: test mock typing
 import {afterEach, beforeEach, describe, expect, it, type mock} from "bun:test";
 import {act, userEvent} from "@testing-library/react-native";
 import {DateTime} from "luxon";

package/src/DateTimeField.tsx

@@ -418,6 +418,7 @@ export const DateTimeField: FC<DateTimeFieldProps> = ({
   helperText,
 }): React.ReactElement => {
   const {theme} = useTheme();
+  // biome-ignore lint/suspicious/noExplicitAny: ActionSheet class is defined in ActionSheet.tsx which imports from Common.ts indirectly; using its type here would create a circular dependency
   const dateActionSheetRef: React.RefObject<any> = React.createRef();
   const [amPm, setAmPm] = useState<"am" | "pm">("am");
   const [showDate, setShowDate] = useState(false);
@@ -567,7 +568,7 @@ export const DateTimeField: FC<DateTimeFieldProps> = ({
       const dayVal = override?.day ?? day;
       const yearVal = override?.year ?? year;
       const hourVal = override?.hour ?? hour;
-      let date;
+      let date: DateTime;
       if (type === "datetime") {
         if (!monthVal || !dayVal || !yearVal || !hour || !minuteVal) {
           return undefined;
@@ -635,7 +636,7 @@ export const DateTimeField: FC<DateTimeFieldProps> = ({
 
       if (date.isValid) {
         // Always return UTC ISO string
-        return date.toUTC().toISO();
+        return date.toUTC().toISO() ?? undefined;
       }
       return undefined;
     },

package/src/DateUtilities.test.ts

@@ -1,5 +1,8 @@
 import {beforeEach, describe, expect, it, mock} from "bun:test";
 import {
+  convertNullToUndefined,
+  getIsoDate,
+  getTimezoneOptions,
   humanDate,
   humanDateAndTime,
   printDate,
@@ -454,5 +457,113 @@ describe("DateUtilities", () => {
       // print without ago
       expect(printSince("2019-12-23T11:00:00.000Z", {showAgo: false})).toBe("3 years");
     });
+
+    it("should throw for invalid date", () => {
+      expect(() => printSince("not-a-date")).toThrow("printSince: Invalid date: not-a-date");
+    });
+  });
+
+  describe("humanDate – non-string input", () => {
+    it("should throw for non-string date", () => {
+      expect(() => humanDate(123 as unknown as string)).toThrow(
+        "humanDate: Invalid date type: number"
+      );
+    });
+  });
+
+  describe("humanDateAndTime – showTimezone false", () => {
+    it("should format time without timezone abbreviation", () => {
+      const result = humanDateAndTime("2022-12-24T12:00:00.000Z", {showTimezone: false});
+      expect(result).toBe("7:00 AM");
+    });
+
+    it("should format tomorrow without timezone abbreviation", () => {
+      const result = humanDateAndTime("2022-12-25T12:00:00.000Z", {showTimezone: false});
+      expect(result).toBe("Tomorrow 7:00 AM");
+    });
+  });
+
+  describe("printDate – showTimezone warning", () => {
+    it("should still return the date when showTimezone is true", () => {
+      const result = printDate("2022-12-24T12:00:00.000Z", {showTimezone: true});
+      expect(result).toBe("12/24/2022");
+    });
+  });
+
+  describe("printDateRange – timeOnly with different dates", () => {
+    it("should warn but still return time range when dates differ", () => {
+      const result = printDateRange("2022-12-24T12:00:00.000Z", "2022-12-25T18:00:00.000Z", {
+        timeOnly: true,
+        timezone: "America/New_York",
+      });
+      expect(result).toBe("7:00 AM - 1:00 PM EST");
+    });
+  });
+
+  describe("convertNullToUndefined", () => {
+    it("should return the string when given a string", () => {
+      expect(convertNullToUndefined("hello")).toBe("hello");
+    });
+
+    it("should return undefined when given null", () => {
+      expect(convertNullToUndefined(null)).toBeUndefined();
+    });
+  });
+
+  describe("getIsoDate", () => {
+    it("should return undefined for undefined input", () => {
+      expect(getIsoDate(undefined)).toBeUndefined();
+    });
+
+    it("should return undefined for empty string", () => {
+      expect(getIsoDate("")).toBeUndefined();
+    });
+
+    it("should return ISO string for valid date", () => {
+      const result = getIsoDate("2022-12-24T12:00:00.000Z");
+      expect(result).toBe("2022-12-24T12:00:00.000Z");
+    });
+  });
+
+  describe("humanDate – non-Error thrown", () => {
+    it("should stringify a non-Error value thrown during date parsing", () => {
+      expect(() => humanDate(42 as unknown as string)).toThrow(
+        "humanDate: Invalid date type: number"
+      );
+    });
+  });
+
+  describe("getTimezoneOptions", () => {
+    it("returns US timezone options with full labels", () => {
+      const options = getTimezoneOptions("USA");
+      expect(options.length).toBe(7);
+      const labels = options.map((o) => o.label);
+      expect(labels).toContain("Eastern");
+      expect(labels).toContain("Pacific");
+      expect(labels).toContain("Arizona");
+    });
+
+    it("returns US timezone options with short labels", () => {
+      const options = getTimezoneOptions("USA", true);
+      expect(options.length).toBe(7);
+      const azOption = options.find((o) => o.value === "America/Phoenix");
+      expect(azOption?.label).toBe("AZ");
+    });
+
+    it("returns worldwide timezone options", () => {
+      const options = getTimezoneOptions("Worldwide");
+      expect(options.length).toBeGreaterThan(7);
+      const values = options.map((o) => o.value);
+      expect(values).toContain("America/New_York");
+    });
+
+    it("returns worldwide timezone options with short labels", () => {
+      const options = getTimezoneOptions("Worldwide", true);
+      expect(options.length).toBeGreaterThan(7);
+      options.forEach((o) => {
+        expect(typeof o.label).toBe("string");
+        expect(typeof o.value).toBe("string");
+      });
+    });
   });
 });

package/src/DateUtilities.tsx

@@ -7,7 +7,7 @@ const getErrorMessage = (error: unknown): string => {
   return String(error);
 };
 
-function getDate(date: string, {timezone}: {timezone?: string} = {}): DateTime {
+const getDate = (date: string, {timezone}: {timezone?: string} = {}): DateTime => {
   if (!date) {
     throw new Error("Passed undefined");
   }
@@ -19,49 +19,49 @@ function getDate(date: string, {timezone}: {timezone?: string} = {}): DateTime {
     throw new Error(`Invalid date: ${date}`);
   }
   return clonedDate;
-}
+};
 
-export function isTomorrow(date: string, {timezone}: {timezone?: string} = {}): boolean {
+export const isTomorrow = (date: string, {timezone}: {timezone?: string} = {}): boolean => {
   const clonedDate = getDate(date, {timezone});
   const now = timezone ? DateTime.now().setZone(timezone) : DateTime.now();
   const diff = now.startOf("day").diff(clonedDate.startOf("day"), "days");
   return diff.days <= -1 && diff.days > -2;
-}
+};
 
-export function isYesterday(date: string, {timezone}: {timezone?: string} = {}): boolean {
+export const isYesterday = (date: string, {timezone}: {timezone?: string} = {}): boolean => {
   const clonedDate = getDate(date, {timezone});
   const now = timezone ? DateTime.now().setZone(timezone) : DateTime.now();
   const diff = now.startOf("day").diff(clonedDate.startOf("day"), "days");
   return diff.days <= 1 && diff.days > -1;
-}
+};
 
-export function isToday(date: string, {timezone}: {timezone?: string} = {}): boolean {
+export const isToday = (date: string, {timezone}: {timezone?: string} = {}): boolean => {
   const clonedDate = getDate(date, {timezone});
   const now = timezone ? DateTime.now().setZone(timezone) : DateTime.now();
   const diff = now.startOf("day").diff(clonedDate.startOf("day"), "days");
   return diff.days === 0;
-}
+};
 
-export function isThisYear(date: string, {timezone}: {timezone?: string} = {}): boolean {
+export const isThisYear = (date: string, {timezone}: {timezone?: string} = {}): boolean => {
   const clonedDate = getDate(date, {timezone});
   const now = timezone ? DateTime.now().setZone(timezone) : DateTime.now();
   return clonedDate.year === now.year;
-}
+};
 
-export function isWithinWeek(date: string, {timezone}: {timezone?: string} = {}): boolean {
+export const isWithinWeek = (date: string, {timezone}: {timezone?: string} = {}): boolean => {
   const clonedDate = getDate(date, {timezone});
   const now = timezone ? DateTime.now().setZone(timezone) : DateTime.now();
   const diff = now.startOf("day").diff(clonedDate.startOf("day"), "days");
   return diff.days > -7 && diff.days < 7;
-}
+};
 
 // Prints a human friendly date, e.g. "Tomorrow", "Yesterday", "Monday", "June 19", "December 25,
 // 2022".
-export function humanDate(
+export const humanDate = (
   date: string,
   {timezone, dontShowTime}: {timezone?: string; dontShowTime?: boolean} = {}
-): string {
-  let clonedDate;
+): string => {
+  let clonedDate: DateTime;
   try {
     clonedDate = getDate(date, {timezone});
   } catch (error: unknown) {
@@ -87,15 +87,15 @@ export function humanDate(
     // December 25, 2022
     return clonedDate.toFormat("MMM d, yyyy");
   }
-}
+};
 
 // Prints a human friendly date and time, e.g. "Tomorrow 9:00 AM", "Yesterday 9:00 AM", "Monday
 // 9:00 AM", "June 19 9:00 AM", "December 25, 2022 9:00 AM".
-export function humanDateAndTime(
+export const humanDateAndTime = (
   date: string,
   {timezone, showTimezone = true}: {timezone?: string; showTimezone?: boolean} = {}
-): string {
-  let clonedDate;
+): string => {
+  let clonedDate: DateTime;
   try {
     clonedDate = getDate(date, {timezone});
   } catch (error: unknown) {
@@ -128,7 +128,7 @@ export function humanDateAndTime(
     // December 25, 2022
     return `${clonedDate.toFormat("MMM d, yyyy")} ${time}`;
   }
-}
+};
 
 // Print date in the format of M/D/YY, taking timezones into account.
 export const printDate = (
@@ -162,7 +162,7 @@ export const printDate = (
     return justDate.startOf("day").toFormat("M/d/yyyy");
   }
 
-  let clonedDate;
+  let clonedDate: DateTime;
   try {
     clonedDate = getDate(date, {timezone});
   } catch (error: unknown) {
@@ -199,7 +199,7 @@ export const printOnlyDate = (
 };
 
 // Print time in the format of HH:mm A, taking timezones into account.
-export function printTime(
+export const printTime = (
   date?: string,
   {
     timezone,
@@ -210,11 +210,11 @@ export function printTime(
     showTimezone?: boolean;
     defaultValue?: string;
   } = {defaultValue: "Invalid Date", timezone: "America/New_York"}
-): string {
+): string => {
   if (!date) {
     return defaultValue ?? "Invalid Date";
   }
-  let clonedDate;
+  let clonedDate: DateTime;
   if (!timezone) {
     throw new Error("printTime: timezone is required");
   }
@@ -232,10 +232,10 @@ export function printTime(
   } else {
     return clonedDate.toLocaleString(DateTime.TIME_SIMPLE);
   }
-}
+};
 
 // Print date in the format of M/D/YY HH:mm A, taking timezones into account.
-export function printDateAndTime(
+export const printDateAndTime = (
   date?: string,
   {
     timezone,
@@ -246,11 +246,11 @@ export function printDateAndTime(
     showTimezone?: boolean;
     defaultValue?: string;
   } = {}
-): string {
+): string => {
   if (!date) {
     return defaultValue ?? "Invalid Datetime";
   }
-  let clonedDate;
+  let clonedDate: DateTime;
   try {
     clonedDate = getDate(date, {timezone});
   } catch (error: unknown) {
@@ -268,12 +268,12 @@ export function printDateAndTime(
   } else {
     return clonedDate.toLocaleString(DateTime.DATETIME_SHORT);
   }
-}
+};
 
 // Prints a date range in the format of M/D/YY HH:mm A - M/D/YY HH:mm A EST, taking timezones into
 // account. If the dates are the same, it will print the date only once, e.g. M/D/YY HH:mm A - HH:mm
 // A EST.
-export function printDateRange(
+export const printDateRange = (
   start: string,
   end: string,
   {
@@ -281,7 +281,7 @@ export function printDateRange(
     showTimezone = true,
     timeOnly,
   }: {timezone: string; showTimezone?: boolean; timeOnly?: boolean}
-): string {
+): string => {
   const startDate = printDate(start, {showTimezone: false, timezone});
   const endDate = printDate(end, {showTimezone: false, timezone});
 
@@ -299,15 +299,15 @@ export function printDateRange(
   } else {
     return `${startDate} ${startTime} - ${endDate} ${endTime}`;
   }
-}
+};
 
 // Print since nicely. If less than 2 months, print days, otherwise print months. If over 1 year,
 // print years.
-export function printSince(
+export const printSince = (
   date: string,
   {timezone, showAgo = true}: {timezone?: string; showAgo?: boolean} = {}
-): string {
-  let clonedDate;
+): string => {
+  let clonedDate: DateTime;
   const ago = showAgo ? " ago" : "";
   try {
     clonedDate = getDate(date, {timezone});
@@ -326,20 +326,20 @@ export function printSince(
     const years = Math.floor(now.diff(clonedDate, "years").years);
     return `${years} ${years === 1 ? "year" : "years"}${ago}`;
   }
-}
+};
 
-export function convertNullToUndefined(value: string | null): string | undefined {
+export const convertNullToUndefined = (value: string | null): string | undefined => {
   return value ?? undefined;
-}
+};
 
 // Get the ISO date string from a date string. If the date string is undefined,
 // return undefined instead of null so MongoDB can handle it.
-export function getIsoDate(date: string | undefined): string | undefined {
+export const getIsoDate = (date: string | undefined): string | undefined => {
   if (!date) {
     return undefined;
   }
   return convertNullToUndefined(DateTime.fromISO(date).toUTC().toISO());
-}
+};
 
 const usTimezoneOptions = [
   {label: "Eastern", value: "America/New_York"},
@@ -351,7 +351,7 @@ const usTimezoneOptions = [
   {label: "Arizona", value: "America/Phoenix"},
 ];
 
-export function getTimezoneOptions(location: "USA" | "Worldwide", shortTimezone = false) {
+export const getTimezoneOptions = (location: "USA" | "Worldwide", shortTimezone = false) => {
   let timezones: [string, string][];
   if (location === "USA") {
     timezones = usTimezoneOptions.map((tz) => [tz.label, tz.value]);
@@ -366,9 +366,8 @@ export function getTimezoneOptions(location: "USA" | "Worldwide", shortTimezone
   }
   return timezones.map(([name, tz]) => {
     const dateTime = DateTime.now().setZone(tz);
-    let tzAbbr = dateTime.toFormat("ZZZZ"); // Gets timezone abbreviation like "EST", "CST", etc.
+    let tzAbbr = dateTime.toFormat("ZZZZ");
 
-    // Special case for Arizona which returns MST during standard time
     if (tz === "America/Phoenix") {
       tzAbbr = "AZ";
     }
@@ -378,4 +377,4 @@ export function getTimezoneOptions(location: "USA" | "Worldwide", shortTimezone
       value: tz,
     };
   });
-}
+};