salat 4.6.2 → 4.9.1

package/dist/components/CitiesApp.test.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, expect, it } from 'vitest';
+import CitiesApp from './CitiesApp.js';
+describe('CitiesApp', () => {
+    it('should render available cities', () => {
+        const { lastFrame } = render(_jsx(CitiesApp, {}));
+        expect(lastFrame()).toContain('Available Cities in Morocco');
+        // Checking some expected cities (from data/cities.json)
+        // I'll assume Casablanca and Rabat are there
+        expect(lastFrame()).toContain('Casablanca');
+        expect(lastFrame()).toContain('Rabat');
+    });
+    it('should display the tip', () => {
+        const { lastFrame } = render(_jsx(CitiesApp, {}));
+        expect(lastFrame()).toContain('Tip: Use these names with the \'times\' command');
+    });
+});

package/dist/components/HelpApp.test.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { describe, expect, it } from 'vitest';
+import HelpApp from './HelpApp.js';
+describe('HelpApp', () => {
+    it('should render help guide', () => {
+        const { lastFrame } = render(_jsx(HelpApp, {}));
+        expect(lastFrame()).toContain('SALAT CLI GUIDE');
+        expect(lastFrame()).toContain('Usage:');
+        expect(lastFrame()).toContain('Commands:');
+        expect(lastFrame()).toContain('Options:');
+    });
+    it('should list available commands', () => {
+        const { lastFrame } = render(_jsx(HelpApp, {}));
+        expect(lastFrame()).toContain('times [city]');
+        expect(lastFrame()).toContain('guide');
+        expect(lastFrame()).toContain('cities');
+    });
+});

package/dist/components/TimesApp.js

@@ -1,68 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { LOCAL_STORAGE_PATH } from "#services/constants";
-import { getCityId, getCityName, getData, getNextPrayer, parsePrayerTimesFromResponse, tConv24, } from "#services/utils";
-import { Box, Text, useApp } from "ink";
-import { useEffect, useState } from "react";
-// @ts-ignore
+import { useSalat } from "#hooks/useSalat";
+import { getNextPrayer, tConv24 } from "#services/utils/time";
 import { format } from "date-fns";
-import { LocalStorage } from "node-localstorage";
-import citiesData from "../data/cities.json" with { type: "json" };
-const cities = citiesData;
-const localStorage = new LocalStorage(LOCAL_STORAGE_PATH);
+import { Box, Text } from "ink";
 const App = ({ cityNameArg, once }) => {
-    const { exit } = useApp();
-    const [prayerTimes, setPrayerTimes] = useState(null);
-    const [error, setError] = useState(null);
-    const [loading, setLoading] = useState(true);
-    const [resolvedCityName, setResolvedCityName] = useState("");
-    const [currentTime, setCurrentTime] = useState(new Date());
-    useEffect(() => {
-        const timer = setInterval(() => {
-            setCurrentTime(new Date());
-        }, 1000);
-        return () => clearInterval(timer);
-    }, []);
-    useEffect(() => {
-        const fetchData = async () => {
-            try {
-                const name = getCityName(cityNameArg, cities);
-                setResolvedCityName(name);
-                const storageKey = `${name.toLowerCase()}_${format(new Date(), "yyyy-MM-dd")}`;
-                let item = localStorage.getItem(storageKey);
-                // Disable localStorage for local development
-                if (process.env.NODE_ENV === "development") {
-                    item = null;
-                }
-                if (item) {
-                    setPrayerTimes(JSON.parse(item));
-                }
-                else {
-                    const cityId = getCityId(name, cities);
-                    const data = await getData(cityId);
-                    const prayers = parsePrayerTimesFromResponse(data);
-                    setPrayerTimes(prayers);
-                    localStorage.setItem(storageKey, JSON.stringify(prayers));
-                }
-            }
-            catch (err) {
-                setError(err.message || "An error occurred");
-            }
-            finally {
-                setLoading(false);
-            }
-        };
-        fetchData();
-    }, [cityNameArg]);
-    useEffect(() => {
-        if (once && !loading && (prayerTimes || error)) {
-            // Small delay to ensure render happens
-            // Ink might need a tick to flush the output to stdout
-            const timer = setTimeout(() => {
-                exit();
-            }, 100);
-            return () => clearTimeout(timer);
-        }
-    }, [once, loading, prayerTimes, error, exit]);
+    const { prayerTimes, error, loading, resolvedCityName, currentTime } = useSalat({
+        cityNameArg,
+        once,
+    });
     if (loading) {
         return _jsx(Text, { children: "Loading prayer times..." });
     }

package/dist/components/TimesApp.test.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSalat } from '#hooks/useSalat';
+import { render } from 'ink-testing-library';
+import { describe, expect, it, vi } from 'vitest';
+import TimesApp from './TimesApp.js';
+vi.mock('#hooks/useSalat', () => ({
+    useSalat: vi.fn()
+}));
+describe('TimesApp', () => {
+    it('should render loading state', () => {
+        (vi.mocked(useSalat)).mockReturnValue({
+            prayerTimes: null,
+            error: null,
+            loading: true,
+            resolvedCityName: '',
+            currentTime: new Date()
+        });
+        const { lastFrame } = render(_jsx(TimesApp, {}));
+        expect(lastFrame()).toContain('Loading prayer times...');
+    });
+    it('should render error state', () => {
+        (vi.mocked(useSalat)).mockReturnValue({
+            prayerTimes: null,
+            error: 'Failed to fetch',
+            loading: false,
+            resolvedCityName: '',
+            currentTime: new Date()
+        });
+        const { lastFrame } = render(_jsx(TimesApp, {}));
+        expect(lastFrame()).toContain('Error: Failed to fetch');
+    });
+    it('should render null prayerTimes state', () => {
+        (vi.mocked(useSalat)).mockReturnValue({
+            prayerTimes: null,
+            error: null,
+            loading: false,
+            resolvedCityName: '',
+            currentTime: new Date()
+        });
+        const { lastFrame } = render(_jsx(TimesApp, {}));
+        expect(lastFrame()).toContain('Could not fetch prayer times.');
+    });
+    it('should render prayer times', () => {
+        const mockPrayerTimes = {
+            Fajr: "05:00",
+            Chorouq: "06:30",
+            Dhuhr: "12:30",
+            Asr: "15:45",
+            Maghrib: "18:20",
+            Ishae: "19:50"
+        };
+        (vi.mocked(useSalat)).mockReturnValue({
+            prayerTimes: mockPrayerTimes,
+            error: null,
+            loading: false,
+            resolvedCityName: 'Marrakech',
+            currentTime: new Date('2026-02-07T10:00:00')
+        });
+        const { lastFrame } = render(_jsx(TimesApp, {}));
+        expect(lastFrame()).toContain('Marrakech, Morocco');
+        expect(lastFrame()).toContain('Fajr');
+        expect(lastFrame()).toContain('05:00 AM');
+        expect(lastFrame()).toContain('Next Prayer: Dhuhr');
+    });
+});

package/dist/hooks/useSalat.js

@@ -0,0 +1,74 @@
+import { LOCAL_STORAGE_PATH } from "#services/constants";
+import { useApp } from "ink";
+import { useEffect, useState } from "react";
+// @ts-ignore
+import { getData } from "#services/utils/api";
+import { getCityId, getCityName } from "#services/utils/city";
+import { parsePrayerTimesFromResponse } from "#services/utils/parser";
+import { format } from "date-fns";
+import { LocalStorage } from "node-localstorage";
+import citiesData from "../data/cities.json" with { type: "json" };
+const cities = citiesData;
+const localStorage = new LocalStorage(LOCAL_STORAGE_PATH);
+export const useSalat = ({ cityNameArg, once }) => {
+    const { exit } = useApp();
+    const [prayerTimes, setPrayerTimes] = useState(null);
+    const [error, setError] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const [resolvedCityName, setResolvedCityName] = useState("");
+    const [currentTime, setCurrentTime] = useState(new Date());
+    useEffect(() => {
+        const timer = setInterval(() => {
+            setCurrentTime(new Date());
+        }, 1000);
+        return () => clearInterval(timer);
+    }, []);
+    useEffect(() => {
+        const fetchData = async () => {
+            try {
+                const name = getCityName(cityNameArg, cities);
+                setResolvedCityName(name);
+                const storageKey = `${name.toLowerCase()}_${format(new Date(), "yyyy-MM-dd")}`;
+                let item = localStorage.getItem(storageKey);
+                // Disable localStorage for local development
+                if (process.env.NODE_ENV === "development") {
+                    item = null;
+                }
+                if (item) {
+                    setPrayerTimes(JSON.parse(item));
+                }
+                else {
+                    const cityId = getCityId(name, cities);
+                    const data = await getData(cityId);
+                    const prayers = parsePrayerTimesFromResponse(data);
+                    setPrayerTimes(prayers);
+                    localStorage.setItem(storageKey, JSON.stringify(prayers));
+                }
+            }
+            catch (err) {
+                setError(err.message || "An error occurred");
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        fetchData();
+    }, [cityNameArg]);
+    useEffect(() => {
+        if (once && !loading && (prayerTimes || error)) {
+            // Small delay to ensure render happens
+            // Ink might need a tick to flush the output to stdout
+            const timer = setTimeout(() => {
+                exit();
+            }, 100);
+            return () => clearTimeout(timer);
+        }
+    }, [once, loading, prayerTimes, error, exit]);
+    return {
+        prayerTimes,
+        error,
+        loading,
+        resolvedCityName,
+        currentTime,
+    };
+};

package/dist/services/utils/api.js

@@ -0,0 +1,5 @@
+import { API_URL } from "#services/constants";
+export const getData = async (cityId) => {
+    const response = await fetch(`${API_URL}?ville=${cityId}`);
+    return await response.text();
+};

package/dist/services/utils/api.test.js

@@ -0,0 +1,23 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as constants from '../constants.js';
+import { getData } from './api.js';
+describe('api utils', () => {
+    describe('getData', () => {
+        beforeEach(() => {
+            vi.stubGlobal('fetch', vi.fn());
+        });
+        it('should fetch data from the correct URL', async () => {
+            const mockResponse = 'mock html content';
+            (vi.mocked(fetch)).mockResolvedValue({
+                text: async () => mockResponse,
+            });
+            const result = await getData(1);
+            expect(fetch).toHaveBeenCalledWith(`${constants.API_URL}?ville=1`);
+            expect(result).toBe(mockResponse);
+        });
+        it('should throw error if fetch fails', async () => {
+            (vi.mocked(fetch)).mockRejectedValue(new Error('Network error'));
+            await expect(getData(1)).rejects.toThrow('Network error');
+        });
+    });
+});

package/dist/services/utils/city.js

@@ -0,0 +1,19 @@
+import { DEFAULT_CITY, NOT_FOUND_ERROR } from "#services/constants";
+export const getCityName = (arg, cities) => {
+    if (arg == null)
+        return DEFAULT_CITY;
+    const index = getCityIndex(arg, cities);
+    if (index === -1) {
+        console.error(NOT_FOUND_ERROR);
+        return DEFAULT_CITY;
+    }
+    return arg;
+};
+export const getCityId = (arg, cities) => {
+    const parsed = parseInt(arg);
+    if (parsed && cities.length >= parsed) {
+        return parsed;
+    }
+    return getCityIndex(arg, cities) + 1;
+};
+export const getCityIndex = (city, cities) => cities.map((e) => e.name.toLowerCase()).indexOf(city.toLowerCase());

package/dist/services/utils/city.test.js

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from 'vitest';
+import * as constants from '../constants.js';
+import { getCityId, getCityIndex, getCityName } from './city.js';
+// Mock cities data
+const mockCities = [
+    { id: 1, name: 'Casablanca' },
+    { id: 2, name: 'Rabat' },
+    { id: 3, name: 'Fes' },
+];
+describe('city utils', () => {
+    describe('getCityName', () => {
+        it('should return the default city if no argument is provided', () => {
+            expect(getCityName(undefined, mockCities)).toBe(constants.DEFAULT_CITY);
+        });
+        it('should return the city name if it exists', () => {
+            expect(getCityName('Casablanca', mockCities)).toBe('Casablanca');
+        });
+        it('should return default city and log error if city does not exist', () => {
+            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            expect(getCityName('UnknownCity', mockCities)).toBe(constants.DEFAULT_CITY);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(constants.NOT_FOUND_ERROR);
+            consoleErrorSpy.mockRestore();
+        });
+        it('should be case insensitive', () => {
+            expect(getCityName('casablanca', mockCities)).toBe('casablanca');
+            expect(getCityName('RaBaT', mockCities)).toBe('RaBaT');
+        });
+    });
+    describe('getCityId', () => {
+        it('should return the ID if a number is provided as string within range', () => {
+            expect(getCityId('2', mockCities)).toBe(2);
+        });
+        it('should return ID from index if number is out of range', () => {
+            // 4 is out of range (mockCities.length is 3)
+            // But if we pass '4', getCityIndex('4', mockCities) returns -1.
+            // So it returns -1 + 1 = 0.
+            expect(getCityId('4', mockCities)).toBe(0);
+        });
+        it('should return the ID based on index + 1 if name is provided', () => {
+            expect(getCityId('Casablanca', mockCities)).toBe(1);
+            expect(getCityId('Rabat', mockCities)).toBe(2);
+        });
+        it('should handle case insensitivity for city names', () => {
+            expect(getCityId('fes', mockCities)).toBe(3);
+        });
+        it('should return 0 if city name is not found', () => {
+            expect(getCityId('Unknown', mockCities)).toBe(0);
+        });
+    });
+    describe('getCityIndex', () => {
+        it('should return the correct index for a city name', () => {
+            expect(getCityIndex('Casablanca', mockCities)).toBe(0);
+            expect(getCityIndex('Rabat', mockCities)).toBe(1);
+        });
+        it('should be case insensitive', () => {
+            expect(getCityIndex('casablanca', mockCities)).toBe(0);
+        });
+        it('should return -1 if city is not found', () => {
+            expect(getCityIndex('NonExistent', mockCities)).toBe(-1);
+        });
+    });
+});

package/dist/services/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./api.js";
+export * from "./city.js";
+export * from "./parser.js";
+export * from "./time.js";

package/dist/services/utils/parser.js

@@ -0,0 +1,20 @@
+import domino from "domino";
+import prayersData from "../../data/prayers.json" with { type: "json" };
+export const parsePrayerTimesFromResponse = (response) => {
+    const window = domino.createWindow(response);
+    const document = window.document;
+    const tds = document.getElementsByTagName("td");
+    const prayers = JSON.parse(JSON.stringify(prayersData));
+    let j = 0;
+    for (let i = 1; i < tds.length && j < prayers.length; i += 2) {
+        prayers[j].time = tds[i].textContent.trim();
+        j++;
+    }
+    // Transform array to object and return it
+    return prayers.reduce((acc, { prayer, time }) => {
+        if (time) {
+            acc[prayer] = time;
+        }
+        return acc;
+    }, {});
+};

package/dist/services/utils/parser.test.js

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { parsePrayerTimesFromResponse } from './parser.js';
+describe('parser utils', () => {
+    describe('parsePrayerTimesFromResponse', () => {
+        it('should parse prayer times correctly from HTML', () => {
+            const mockHtml = `
+            <html>
+                <body>
+                    <table>
+                        <tr><td>Ignored</td><td>05:30</td></tr>
+                        <tr><td>Ignored</td><td>07:00</td></tr>
+                        <tr><td>Ignored</td><td>12:30</td></tr>
+                        <tr><td>Ignored</td><td>15:45</td></tr>
+                        <tr><td>Ignored</td><td>18:20</td></tr>
+                        <tr><td>Ignored</td><td>19:50</td></tr>
+                    </table>
+                </body>
+            </html>
+            `;
+            const results = parsePrayerTimesFromResponse(mockHtml);
+            expect(results.Fajr).toBe('05:30');
+            expect(results.Chorouq).toBe('07:00');
+            expect(results.Dhuhr).toBe('12:30');
+            expect(results.Asr).toBe('15:45');
+            expect(results.Maghrib).toBe('18:20');
+            expect(results.Ishae).toBe('19:50');
+        });
+        it('should handle empty or invalid HTML and return empty object', () => {
+            const results = parsePrayerTimesFromResponse('<html></html>');
+            expect(results).toEqual({});
+        });
+    });
+});

package/dist/services/utils/time.js

@@ -0,0 +1,26 @@
+import { addDays, format, intervalToDuration, parse } from "date-fns";
+export function tConv24(time24) {
+    const date = parse(time24, "HH:mm", new Date());
+    return format(date, "hh:mm a");
+}
+export function getNextPrayer(prayerTimes, now) {
+    const prayerNames = ["Fajr", "Chorouq", "Dhuhr", "Asr", "Maghrib", "Ishae"];
+    const prayersWithDates = prayerNames.map((name) => ({
+        name,
+        time: prayerTimes[name],
+        date: parse(prayerTimes[name], "HH:mm", now),
+    }));
+    const next = prayersWithDates.find((p) => p.date > now) || {
+        ...prayersWithDates[0],
+        date: addDays(prayersWithDates[0].date, 1),
+    };
+    const duration = intervalToDuration({ start: now, end: next.date });
+    const timeLeft = [duration.hours, duration.minutes, duration.seconds]
+        .map((v) => String(v ?? 0).padStart(2, "0"))
+        .join(":");
+    return {
+        prayer: next.name,
+        time: next.time,
+        timeLeft,
+    };
+}

package/dist/services/utils/time.test.js

@@ -0,0 +1,50 @@
+import { parseISO } from 'date-fns';
+import { describe, expect, it } from 'vitest';
+import { getNextPrayer, tConv24 } from './time.js';
+describe('time utils', () => {
+    describe('tConv24', () => {
+        it('should convert 24h time to 12h format with AM/PM', () => {
+            expect(tConv24('13:30')).toBe('01:30 PM');
+            expect(tConv24('05:15')).toBe('05:15 AM');
+            expect(tConv24('00:00')).toBe('12:00 AM');
+            expect(tConv24('12:00')).toBe('12:00 PM');
+        });
+    });
+    describe('getNextPrayer', () => {
+        const prayerTimes = {
+            Fajr: "05:30",
+            Chorouq: "07:00",
+            Dhuhr: "12:30",
+            Asr: "15:45",
+            Maghrib: "18:20",
+            Ishae: "19:50"
+        };
+        it('should return Fajr if current time is before Fajr', () => {
+            const now = parseISO('2026-02-07T04:00:00');
+            const result = getNextPrayer(prayerTimes, now);
+            expect(result.prayer).toBe('Fajr');
+            expect(result.time).toBe('05:30');
+            expect(result.timeLeft).toBe('01:30:00');
+        });
+        it('should return Dhuhr if current time is between Chorouq and Dhuhr', () => {
+            const now = parseISO('2026-02-07T10:00:00');
+            const result = getNextPrayer(prayerTimes, now);
+            expect(result.prayer).toBe('Dhuhr');
+            expect(result.time).toBe('12:30');
+            expect(result.timeLeft).toBe('02:30:00');
+        });
+        it('should return tomorrow Fajr if current time is after Ishae', () => {
+            const now = parseISO('2026-02-07T21:00:00');
+            const result = getNextPrayer(prayerTimes, now);
+            expect(result.prayer).toBe('Fajr');
+            expect(result.time).toBe('05:30');
+            expect(result.timeLeft).toBe('08:30:00');
+        });
+        it('should handle seconds correctly in timeLeft', () => {
+            const now = parseISO('2026-02-07T12:29:45');
+            const result = getNextPrayer(prayerTimes, now);
+            expect(result.prayer).toBe('Dhuhr');
+            expect(result.timeLeft).toBe('00:00:15');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salat",
-  "version": "4.6.2",
+  "version": "4.9.1",
   "imports": {
     "#*": "./dist/*.js"
   },
@@ -19,7 +19,6 @@
     "date-fns": "^4.1.0",
     "domino": "^2.1.6",
     "ink": "^6.6.0",
-    "node-fetch": "^3.3.2",
     "node-localstorage": "^3.0.5",
     "react": "^19.2.4"
   },
@@ -29,7 +28,9 @@
     "start": "node dist/app.js",
     "prestart": "npm run build",
     "prepublishOnly": "npm run build",
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:ci": "vitest run --exclude tests/**",
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [
     "prayers",
@@ -44,10 +45,11 @@
   "license": "MIT",
   "devDependencies": {
     "@types/node": "^25.2.1",
-    "@types/node-fetch": "^2.6.13",
     "@types/node-localstorage": "^1.3.3",
     "@types/react": "^19.2.13",
     "@types/react-dom": "^19.2.3",
+    "@vitest/coverage-v8": "^4.0.18",
+    "ink-testing-library": "^4.0.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"

package/dist/services/utils.js

@@ -1,80 +0,0 @@
-import { API_URL, DEFAULT_CITY, NOT_FOUND_ERROR } from "#services/constants";
-import { addDays, differenceInSeconds, format, parse } from "date-fns";
-import domino from "domino";
-import fetch from "node-fetch";
-import https from "node:https";
-import prayersData from "../data/prayers.json" with { type: "json" };
-const httpsAgent = new https.Agent({
-    rejectUnauthorized: false,
-});
-export const getCityName = (arg, cities) => {
-    if (arg == null)
-        return DEFAULT_CITY;
-    const index = getCityIndex(arg, cities);
-    if (index === -1) {
-        console.error(NOT_FOUND_ERROR);
-        return DEFAULT_CITY;
-    }
-    return arg;
-};
-export const getCityId = (arg, cities) => {
-    const parsed = parseInt(arg);
-    if (parsed && cities.length >= parsed) {
-        return parsed;
-    }
-    return getCityIndex(arg, cities) + 1;
-};
-const getCityIndex = (city, cities) => cities.map((e) => e.name.toLowerCase()).indexOf(city.toLowerCase());
-export const getData = async (cityId) => {
-    const response = await fetch(`${API_URL}?ville=${cityId}`, {
-        agent: httpsAgent,
-    });
-    return await response.text();
-};
-export const parsePrayerTimesFromResponse = (response) => {
-    const window = domino.createWindow(response);
-    const document = window.document;
-    const tds = document.getElementsByTagName("td");
-    const prayers = JSON.parse(JSON.stringify(prayersData));
-    let j = 0;
-    for (let i = 1; i < tds.length && j < prayers.length; i += 2) {
-        prayers[j].time = tds[i].textContent.trim();
-        j++;
-    }
-    // Transform array to object and return it
-    return prayers.reduce((acc, { prayer, time }) => {
-        if (time) {
-            acc[prayer] = time;
-        }
-        return acc;
-    }, {});
-};
-export function tConv24(time24) {
-    const date = parse(time24, "HH:mm", new Date());
-    return format(date, "hh:mm a");
-}
-export function getNextPrayer(prayerTimes, now) {
-    const prayerNames = ["Fajr", "Chorouq", "Dhuhr", "Asr", "Maghrib", "Ishae"];
-    const prayersWithDates = prayerNames.map((name) => {
-        const time = prayerTimes[name];
-        const prayerDate = parse(time, "HH:mm", now);
-        return { name, date: prayerDate, time };
-    });
-    let next = prayersWithDates.find((p) => p.date > now);
-    if (!next) {
-        const firstPrayerName = prayerNames[0];
-        const firstTime = prayerTimes[firstPrayerName];
-        const tomorrowFajr = addDays(parse(firstTime, "HH:mm", now), 1);
-        next = { name: firstPrayerName, date: tomorrowFajr, time: firstTime };
-    }
-    const diffSec = differenceInSeconds(next.date, now);
-    const h = Math.floor(diffSec / 3600);
-    const m = Math.floor((diffSec % 3600) / 60);
-    const s = diffSec % 60;
-    const timeLeft = `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
-    return {
-        prayer: next.name,
-        time: next.time,
-        timeLeft,
-    };
-}

package/dist/services/utils.test.js

@@ -1,116 +0,0 @@
-import * as constants from '#services/constants';
-import { getCityId, getCityName, getNextPrayer, parsePrayerTimesFromResponse } from '#services/utils';
-import { parseISO } from 'date-fns';
-import { describe, expect, it, vi } from 'vitest';
-// Mock cities data
-const mockCities = [
-    { id: 1, name: 'Casablanca' },
-    { id: 2, name: 'Rabat' },
-    { id: 3, name: 'Fes' },
-];
-describe('utils', () => {
-    describe('getCityName', () => {
-        it('should return the default city if no argument is provided', () => {
-            expect(getCityName(undefined, mockCities)).toBe(constants.DEFAULT_CITY);
-        });
-        it('should return the city name if it exists', () => {
-            expect(getCityName('Casablanca', mockCities)).toBe('Casablanca');
-        });
-        it('should return default city and log error if city does not exist', () => {
-            // Spy on console.error using vitest
-            const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-            const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            expect(getCityName('UnknownCity', mockCities)).toBe(constants.DEFAULT_CITY);
-            // We expect some error message to be logged. 
-            // The actual implementation logs with chalk.red, so we just check it was called.
-            expect(consoleLogSpy.mock.calls.length + consoleErrorSpy.mock.calls.length).toBeGreaterThan(0);
-            consoleLogSpy.mockRestore();
-            consoleErrorSpy.mockRestore();
-        });
-        it('should be case insensitive', () => {
-            expect(getCityName('casablanca', mockCities)).toBe('casablanca');
-            expect(getCityName('RaBaT', mockCities)).toBe('RaBaT');
-        });
-    });
-    describe('getCityId', () => {
-        it('should return the ID if a number is provided as string', () => {
-            expect(getCityId('2', mockCities)).toBe(2);
-        });
-        it('should return the ID based on index + 1 if name is provided', () => {
-            // 'Casablanca' is at index 0, so ID should be 1
-            expect(getCityId('Casablanca', mockCities)).toBe(1);
-            // 'Rabat' is at index 1, so ID should be 2
-            expect(getCityId('Rabat', mockCities)).toBe(2);
-        });
-        it('should handle case insensitivity for city names', () => {
-            expect(getCityId('fes', mockCities)).toBe(3);
-        });
-    });
-    describe('parsePrayerTimesFromResponse', () => {
-        it('should parse prayer times correctly from HTML', () => {
-            const mockHtml = `
-            <html>
-                <body>
-                    <table>
-                        <tr><td>Fajr</td><td>05:30</td></tr>
-                        <tr><td>Chourouk</td><td>07:00</td></tr>
-                        <tr><td>Dhuhr</td><td>12:30</td></tr>
-                        <tr><td>Asr</td><td>15:45</td></tr>
-                        <tr><td>Maghrib</td><td>18:20</td></tr>
-                        <tr><td>Isha</td><td>19:50</td></tr>
-                    </table>
-                </body>
-            </html>
-            `;
-            // Note: The actual implementation expects td elements in a specific order (key, value, key, value...)
-            // And it relies on prayersData keys. 
-            // We need to match the structure expected by the function.
-            // The function iterates tds with i=1, i+=2. meaning it takes index 1, 3, 5... as times.
-            const results = parsePrayerTimesFromResponse(mockHtml);
-            // Based on default prayers.json keys, let's assume we expect those values.
-            // Since we mocked the HTML, if the code pushes to 'prayers' array from 'prayersData',
-            // and then updates .time property from tds.
-            // checking if it returns an object with times
-            expect(results).toHaveProperty('Fajr');
-            expect(results).toHaveProperty('Dhuhr');
-        });
-    });
-    describe('getNextPrayer', () => {
-        const prayerTimes = {
-            Fajr: "05:30",
-            Chorouq: "07:00",
-            Dhuhr: "12:30",
-            Asr: "15:45",
-            Maghrib: "18:20",
-            Ishae: "19:50"
-        };
-        it('should return Fajr if current time is before Fajr', () => {
-            const now = parseISO('2026-02-07T04:00:00');
-            const result = getNextPrayer(prayerTimes, now);
-            expect(result.prayer).toBe('Fajr');
-            expect(result.time).toBe('05:30');
-            expect(result.timeLeft).toBe('01:30:00');
-        });
-        it('should return Dhuhr if current time is between Chorouq and Dhuhr', () => {
-            const now = parseISO('2026-02-07T10:00:00');
-            const result = getNextPrayer(prayerTimes, now);
-            expect(result.prayer).toBe('Dhuhr');
-            expect(result.time).toBe('12:30');
-            expect(result.timeLeft).toBe('02:30:00');
-        });
-        it('should return tomorrow Fajr if current time is after Ishae', () => {
-            const now = parseISO('2026-02-07T21:00:00');
-            const result = getNextPrayer(prayerTimes, now);
-            expect(result.prayer).toBe('Fajr');
-            expect(result.time).toBe('05:30');
-            // From 21:00 to 05:30 next day is 8 hours and 30 minutes
-            expect(result.timeLeft).toBe('08:30:00');
-        });
-        it('should handle seconds correctly in timeLeft', () => {
-            const now = parseISO('2026-02-07T12:29:45');
-            const result = getNextPrayer(prayerTimes, now);
-            expect(result.prayer).toBe('Dhuhr');
-            expect(result.timeLeft).toBe('00:00:15');
-        });
-    });
-});