Remove additional type

Author: timmo001

src/common/condition/time-calculator.ts

@@ -18,7 +18,7 @@ import type { TimeCondition } from "../../panels/lovelace/common/validate-condit
  */
 export function calculateNextTimeUpdate(
   hass: HomeAssistant,
-  { after, before, weekdays }: TimeCondition
+  { after, before, weekdays }: Omit<TimeCondition, "condition">
 ): number | undefined {
   const timezone =
     hass.locale.time_zone === TimeZone.server

src/common/datetime/check_time.ts

@@ -2,7 +2,8 @@ import { TZDate } from "@date-fns/tz";
 import { isBefore, isAfter, isWithinInterval } from "date-fns";
 import type { HomeAssistant } from "../../types";
 import { TimeZone } from "../../data/translation";
-import { WEEKDAY_MAP, type WeekdayShort } from "./weekday";
+import { WEEKDAY_MAP } from "./weekday";
+import type { TimeCondition } from "../../panels/lovelace/common/validate-condition";
 
 /**
  * Parse a time string (HH:MM or HH:MM:SS) and set it on today's date in the given timezone
@@ -56,16 +57,12 @@ export const parseTimeString = (timeString: string, timezone: string): Date => {
 /**
  * Check if the current time matches the time condition (after/before/weekday)
  * @param hass Home Assistant object
- * @param after Optional time string (HH:MM) for after condition
- * @param before Optional time string (HH:MM) for before condition
- * @param weekdays Optional array of weekdays to match
+ * @param timeCondition Time condition to check
  * @returns true if current time matches the condition
  */
 export const checkTimeInRange = (
   hass: HomeAssistant,
-  after?: string,
-  before?: string,
-  weekdays?: WeekdayShort[]
+  { after, before, weekdays }: Omit<TimeCondition, "condition">
 ): boolean => {
   const timezone =
     hass.locale.time_zone === TimeZone.server

src/panels/lovelace/common/validate-condition.ts

@@ -162,13 +162,11 @@ function checkScreenCondition(condition: ScreenCondition, _: HomeAssistant) {
     : false;
 }
 
-function checkTimeCondition(condition: TimeCondition, hass: HomeAssistant) {
-  return checkTimeInRange(
-    hass,
-    condition.after,
-    condition.before,
-    condition.weekdays
-  );
+function checkTimeCondition(
+  condition: Omit<TimeCondition, "condition">,
+  hass: HomeAssistant
+) {
+  return checkTimeInRange(hass, condition);
 }
 
 function checkLocationCondition(

test/common/datetime/check_time.test.ts

@@ -37,21 +37,27 @@ describe("checkTimeInRange", () => {
       // Set time to 10:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "08:00", before: "17:00" })
+      ).toBe(true);
     });
 
     it("should return false when current time is before range", () => {
       // Set time to 7:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 7, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00")).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, { after: "08:00", before: "17:00" })
+      ).toBe(false);
     });
 
     it("should return false when current time is after range", () => {
       // Set time to 6:00 PM
       vi.setSystemTime(new Date(2024, 0, 15, 18, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00")).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, { after: "08:00", before: "17:00" })
+      ).toBe(false);
     });
   });
 
@@ -60,45 +66,51 @@ describe("checkTimeInRange", () => {
       // Set time to 11:00 PM
       vi.setSystemTime(new Date(2024, 0, 15, 23, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "22:00", "06:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "22:00", before: "06:00" })
+      ).toBe(true);
     });
 
     it("should return true when current time is after midnight", () => {
       // Set time to 3:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 3, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "22:00", "06:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "22:00", before: "06:00" })
+      ).toBe(true);
     });
 
     it("should return false when outside the range", () => {
       // Set time to 10:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "22:00", "06:00")).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, { after: "22:00", before: "06:00" })
+      ).toBe(false);
     });
   });
 
   describe("only 'after' condition", () => {
     it("should return true when after specified time", () => {
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
-      expect(checkTimeInRange(mockHass, "08:00")).toBe(true);
+      expect(checkTimeInRange(mockHass, { after: "08:00" })).toBe(true);
     });
 
     it("should return false when before specified time", () => {
       vi.setSystemTime(new Date(2024, 0, 15, 6, 0, 0));
-      expect(checkTimeInRange(mockHass, "08:00")).toBe(false);
+      expect(checkTimeInRange(mockHass, { after: "08:00" })).toBe(false);
     });
   });
 
   describe("only 'before' condition", () => {
     it("should return true when before specified time", () => {
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
-      expect(checkTimeInRange(mockHass, undefined, "17:00")).toBe(true);
+      expect(checkTimeInRange(mockHass, { before: "17:00" })).toBe(true);
     });
 
     it("should return false when after specified time", () => {
       vi.setSystemTime(new Date(2024, 0, 15, 18, 0, 0));
-      expect(checkTimeInRange(mockHass, undefined, "17:00")).toBe(false);
+      expect(checkTimeInRange(mockHass, { before: "17:00" })).toBe(false);
     });
   });
 
@@ -107,26 +119,22 @@ describe("checkTimeInRange", () => {
       // January 15, 2024 is a Monday
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, undefined, undefined, ["mon"])).toBe(
-        true
-      );
+      expect(checkTimeInRange(mockHass, { weekdays: ["mon"] })).toBe(true);
     });
 
     it("should return false on non-matching weekday", () => {
       // January 15, 2024 is a Monday
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, undefined, undefined, ["tue"])).toBe(
-        false
-      );
+      expect(checkTimeInRange(mockHass, { weekdays: ["tue"] })).toBe(false);
     });
 
     it("should work with multiple weekdays", () => {
       // January 15, 2024 is a Monday
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
       expect(
-        checkTimeInRange(mockHass, undefined, undefined, ["mon", "wed", "fri"])
+        checkTimeInRange(mockHass, { weekdays: ["mon", "wed", "fri"] })
       ).toBe(true);
     });
   });
@@ -136,29 +144,49 @@ describe("checkTimeInRange", () => {
       // January 15, 2024 is a Monday at 10:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00", ["mon"])).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, {
+          after: "08:00",
+          before: "17:00",
+          weekdays: ["mon"],
+        })
+      ).toBe(true);
     });
 
     it("should return false when time matches but weekday doesn't", () => {
       // January 15, 2024 is a Monday at 10:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00", ["tue"])).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, {
+          after: "08:00",
+          before: "17:00",
+          weekdays: ["tue"],
+        })
+      ).toBe(false);
     });
 
     it("should return false when weekday matches but time doesn't", () => {
       // January 15, 2024 is a Monday at 6:00 AM
       vi.setSystemTime(new Date(2024, 0, 15, 6, 0, 0));
 
-      expect(checkTimeInRange(mockHass, "08:00", "17:00", ["mon"])).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, {
+          after: "08:00",
+          before: "17:00",
+          weekdays: ["mon"],
+        })
+      ).toBe(false);
     });
   });
 
   describe("no conditions", () => {
     it("should return true when no conditions specified", () => {
       vi.setSystemTime(new Date(2024, 0, 15, 10, 0, 0));
 
-      expect(checkTimeInRange(mockHass)).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "08:00", before: "17:00" })
+      ).toBe(true);
     });
   });
 
@@ -169,15 +197,19 @@ describe("checkTimeInRange", () => {
       vi.setSystemTime(new Date(2024, 2, 10, 1, 30, 0));
 
       // Should be within range that crosses the transition
-      expect(checkTimeInRange(mockHass, "01:00", "04:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "01:00", before: "04:00" })
+      ).toBe(true);
     });
 
     it("should handle spring forward transition after the jump", () => {
       // March 10, 2024 at 3:30 AM PDT - after spring forward
       vi.setSystemTime(new Date(2024, 2, 10, 3, 30, 0));
 
       // Should still be within range
-      expect(checkTimeInRange(mockHass, "01:00", "04:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "01:00", before: "04:00" })
+      ).toBe(true);
     });
 
     it("should handle fall back transition (gaining an hour)", () => {
@@ -186,24 +218,32 @@ describe("checkTimeInRange", () => {
       vi.setSystemTime(new Date(2024, 10, 3, 1, 30, 0));
 
       // Should be within range that crosses the transition
-      expect(checkTimeInRange(mockHass, "01:00", "03:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "01:00", before: "03:00" })
+      ).toBe(true);
     });
 
     it("should handle midnight crossing during DST transition", () => {
       // March 10, 2024 at 1:00 AM - during spring forward night
       vi.setSystemTime(new Date(2024, 2, 10, 1, 0, 0));
 
       // Range that crosses midnight and DST transition
-      expect(checkTimeInRange(mockHass, "22:00", "04:00")).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "22:00", before: "04:00" })
+      ).toBe(true);
     });
 
     it("should correctly compare times on DST transition day", () => {
       // November 3, 2024 at 10:00 AM - after fall back completed
       vi.setSystemTime(new Date(2024, 10, 3, 10, 0, 0));
 
       // Normal business hours should work correctly
-      expect(checkTimeInRange(mockHass, "08:00", "17:00")).toBe(true);
-      expect(checkTimeInRange(mockHass, "12:00", "17:00")).toBe(false);
+      expect(
+        checkTimeInRange(mockHass, { after: "08:00", before: "17:00" })
+      ).toBe(true);
+      expect(
+        checkTimeInRange(mockHass, { after: "12:00", before: "17:00" })
+      ).toBe(false);
     });
   });
 });