@max-xoo/mawaqit 1.0.0 → 1.5.0

package/README.MD

@@ -0,0 +1,196 @@
+# mawaqit
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme) ![npm](https://img.shields.io/npm/v/@max-xoo/mawaqit?color=green) [![npm download month](https://img.shields.io/npm/dm/@max-xoo/mawaqit.svg)](https://www.npmjs.com/package/@max-xoo/mawaqit)
+
+A Node.js wrapper around [Mawaqit](https://mawaqit.net/), fetching mosque prayer times with built-in cache, country-wide mosque listings, and search.
+
+## Table of Contents
+- [Install](#install)
+- [Usage](#usage)
+  - [Prayer Times](#prayer-times)
+  - [Calendar](#calendar)
+  - [Mosque Info](#mosque-info)
+  - [Country / Map](#country--map)
+  - [Geolocation](#geolocation)
+  - [Search](#search)
+  - [Bulk Operations](#bulk-operations)
+  - [Raw Data](#raw-data)
+- [Cache](#cache)
+- [Error Handling](#error-handling)
+- [Contributing](#contributing)
+
+## Install
+```sh
+npm install @max-xoo/mawaqit
+```
+
+## Usage
+This package is meant to be used in the backend (Node.js).
+All methods return a promise. The mosque slug is the one found in the mawaqit.net URL (e.g. `https://mawaqit.net/fr/zawiya-tidjaniya-trappes`).
+
+### Prayer Times
+```js
+const mawaqit = require("@max-xoo/mawaqit");
+
+const times = await mawaqit.getPrayerTimesOfTheDay("zawiya-tidjaniya-trappes");
+// { fajr, sunrise, dohr, asr, maghreb, icha }
+
+const iqama = await mawaqit.getIqamaTimes("zawiya-tidjaniya-trappes");
+// { fajr, dohr, asr, maghreb, icha } (today's iqama, null if disabled)
+
+const next = await mawaqit.getNextPrayer("zawiya-tidjaniya-trappes");
+// { name: "asr", time: "16:45" } or { name: "fajr", time: "05:30", tomorrow: true }
+
+const jumua = await mawaqit.getJumuaTimes("zawiya-tidjaniya-trappes");
+// { jumua: "13:00", jumua2: "13:40", jumuaAsDuhr: false }
+```
+
+### Calendar
+```js
+const calendar = await mawaqit.getCalendar("zawiya-tidjaniya-trappes");
+// Full year calendar (12 months)
+
+const march = await mawaqit.getMonth("zawiya-tidjaniya-trappes", 3);
+// [{ fajr, sunrise, dohr, asr, maghreb, icha }, ...] for each day
+
+const day = await mawaqit.getDay("zawiya-tidjaniya-trappes", 3, 15);
+// { fajr, sunrise, dohr, asr, maghreb, icha } for March 15
+
+const iqamaMarch = await mawaqit.getMonthIqama("zawiya-tidjaniya-trappes", 3);
+// [{ fajr, dohr, asr, maghreb, icha }, ...] for each day
+```
+
+### Mosque Info
+```js
+const services = await mawaqit.getServices("zawiya-tidjaniya-trappes");
+// { name, label, localisation, phone, email, site, mosqueeType, association }
+
+const info = await mawaqit.getMosqueInfo("zawiya-tidjaniya-trappes");
+// Full info: name, label, localisation, phone, email, site, image,
+// womenSpace, janazaPrayer, aidPrayer, childrenCourses, adultCourses,
+// ramadanMeal, handicapAccessibility, ablutions, parking, iqamaEnabled, ...
+
+const announcements = await mawaqit.getAnnouncements("zawiya-tidjaniya-trappes");
+// [{ ... }]
+
+const flash = await mawaqit.getFlashMessage("zawiya-tidjaniya-trappes");
+// string or null
+```
+
+### Country / Map
+Fetch all mosques registered on Mawaqit for a given country using 2-letter ISO codes.
+```js
+const mosques = await mawaqit.getMosquesByCountry("FR");
+// [{ slug, name, image1, address, city, zipcode, countryFullName, lng, lat }, ...]
+
+const count = await mawaqit.getMosquesByCountryCount("FR");
+// 4500
+
+const byCity = await mawaqit.getMosquesByCity("FR", "Paris");
+// All mosques in Paris
+
+const byZip = await mawaqit.getMosquesByZipcode("FR", "78000");
+// All mosques with zipcode 78000
+
+const byName = await mawaqit.getMosquesByName("FR", "essalam");
+// All mosques whose name contains "essalam"
+```
+
+### Geolocation
+Find mosques near GPS coordinates. Distance is returned in km.
+```js
+const nearby = await mawaqit.getMosquesByRadius("FR", 48.8566, 2.3522, 5);
+// Mosques within 5km of central Paris, sorted by distance
+// [{ slug, name, city, distance: 0.8, ... }, ...]
+
+const nearest = await mawaqit.getNearestMosque("FR", 48.8566, 2.3522);
+// Single closest mosque or null
+
+const top5 = await mawaqit.getNearestMosques("FR", 48.8566, 2.3522, 5);
+// 5 closest mosques
+```
+
+### Search
+Uses Mawaqit's search API to find mosques by name, city, or zipcode.
+```js
+const results = await mawaqit.searchMosques("versailles", "slug,label");
+// Full search results from the API
+
+const byName = await mawaqit.searchByName("mosquée de versailles");
+const byZip = await mawaqit.searchByZipcode("78000");
+const byCity = await mawaqit.searchByCity("Versailles");
+// Shorthand searches returning [{ slug, label, ... }]
+
+const full = await mawaqit.searchFull("versailles");
+// All fields returned (uuid, name, type, times, iqama, jumua, ...)
+
+const withTimes = await mawaqit.searchWithTimes("versailles");
+// [{ slug, name, localisation, times: { fajr, ... }, iqama, jumua }]
+```
+
+### Bulk Operations
+```js
+const all = await mawaqit.getAllCountryMosquesWithTimes("FR");
+// All mosques in France with today's prayer times (slow, use with care)
+
+const multi = await mawaqit.getMultipleMosqueTimes([
+  "zawiya-tidjaniya-trappes",
+  "mosquee-de-versailles-versailles-78000-france",
+]);
+// { "zawiya-tidjaniya-trappes": { fajr, ... }, "mosquee-de-...": { fajr, ... } }
+```
+
+### Raw Data
+```js
+const raw = await mawaqit.fetchMawaqit("zawiya-tidjaniya-trappes");
+// Full confData object from mawaqit.net
+
+const rawConf = await mawaqit.getRawConfData("zawiya-tidjaniya-trappes");
+// Same as above (alias)
+```
+
+## Cache
+Data is cached in memory with different TTLs depending on the type:
+- **confData** (prayer times): resets at **midnight**
+- **Country/map data**: cached for **6 hours**
+- **Search results**: cached for **30 minutes**
+
+```js
+mawaqit.clearCache();                          // Clear all entries
+mawaqit.deleteCacheEntry("conf:mosque-slug");  // Clear a specific mosque
+const size = mawaqit.getCacheSize();           // Number of cached entries
+const keys = mawaqit.getCacheKeys();           // List all cache keys
+const exists = mawaqit.hasCache("conf:slug");  // Check if key is cached
+```
+
+## Error Handling
+```js
+const {
+  MawaqitNotFoundError,
+  MawaqitParseError,
+  MawaqitFetchError,
+  MawaqitValidationError,
+  MawaqitSearchError,
+  MawaqitCountryError,
+} = require("@max-xoo/mawaqit");
+
+try {
+  const times = await mawaqit.getPrayerTimesOfTheDay("unknown-mosque");
+} catch (err) {
+  if (err instanceof MawaqitNotFoundError) {
+    console.error("Mosque not found:", err.message);   // 404
+  } else if (err instanceof MawaqitFetchError) {
+    console.error("Network error:", err.message);      // 502
+  } else if (err instanceof MawaqitParseError) {
+    console.error("Parse error:", err.message);        // 500
+  } else if (err instanceof MawaqitValidationError) {
+    console.error("Bad input:", err.message);          // 400
+  } else if (err instanceof MawaqitSearchError) {
+    console.error("Search failed:", err.message);      // 502
+  } else if (err instanceof MawaqitCountryError) {
+    console.error("Country fetch failed:", err.message); // 502
+  }
+}
+```
+
+## Contributing
+Feel free to [open an issue](https://github.com/roimee6/mawaqit/issues/new) or submit a pull request.

package/dist/cache.js

@@ -16,10 +16,10 @@ function getFromCache(key) {
     return entry.data;
 }
 
-function setToCache(key, data) {
+function setToCache(key, data, ttlMs) {
     cache.set(key, {
         data,
-        expiresAt: Date.now() + getMsUntilMidnight(),
+        expiresAt: Date.now() + (ttlMs || getMsUntilMidnight()),
     });
 }
 
@@ -35,10 +35,26 @@ function getCacheSize() {
     return cache.size;
 }
 
+function getCacheKeys() {
+    return [...cache.keys()];
+}
+
+function hasCache(key) {
+    const entry = cache.get(key);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+        cache.delete(key);
+        return false;
+    }
+    return true;
+}
+
 module.exports = {
     getFromCache,
     setToCache,
     clearCache,
     deleteCacheEntry,
     getCacheSize,
+    getCacheKeys,
+    hasCache,
 };

package/dist/errors.js

@@ -34,10 +34,26 @@ class MawaqitValidationError extends MawaqitError {
     }
 }
 
+class MawaqitSearchError extends MawaqitError {
+    constructor(query) {
+        super(`Search failed for "${query}"`, 502);
+        this.name = "MawaqitSearchError";
+    }
+}
+
+class MawaqitCountryError extends MawaqitError {
+    constructor(countryCode) {
+        super(`Failed to fetch mosques for country "${countryCode}"`, 502);
+        this.name = "MawaqitCountryError";
+    }
+}
+
 module.exports = {
     MawaqitError,
     MawaqitNotFoundError,
     MawaqitParseError,
     MawaqitFetchError,
     MawaqitValidationError,
+    MawaqitSearchError,
+    MawaqitCountryError,
 };

package/dist/fetch.js

@@ -1,26 +1,22 @@
 const axios = require("axios");
-
-const {
-    load
-} = require("cheerio");
-const {
-    getFromCache,
-    setToCache
-} = require("./cache");
-
+const { load } = require("cheerio");
+const { getFromCache, setToCache } = require("./cache");
 const {
     MawaqitNotFoundError,
     MawaqitParseError,
     MawaqitFetchError,
+    MawaqitSearchError,
+    MawaqitCountryError,
 } = require("./errors");
 
 const CONF_DATA_REGEX = /(?:var|let)\s+confData\s*=\s*(.*?);/s;
+const BASE_API = "https://mawaqit.net/api/2.0";
+const MAP_CACHE_TTL = 6 * 60 * 60 * 1000; // 6h
+const SEARCH_CACHE_TTL = 30 * 60 * 1000; // 30min
 
 async function fetchMawaqit(masjidId) {
-    const cached = getFromCache(masjidId);
-    if (cached) {
-        return cached;
-    }
+    const cached = getFromCache(`conf:${masjidId}`);
+    if (cached) return cached;
 
     const url = `https://mawaqit.net/fr/${masjidId}`;
     let response;
@@ -37,7 +33,7 @@ async function fetchMawaqit(masjidId) {
     let confData = null;
 
     $("script").each((_, el) => {
-        if (confData) return; // already found
+        if (confData) return;
         const content = $(el).html();
         if (content && CONF_DATA_REGEX.test(content)) {
             const match = content.match(CONF_DATA_REGEX);
@@ -51,14 +47,50 @@ async function fetchMawaqit(masjidId) {
         }
     });
 
-    if (!confData) {
-        throw new MawaqitParseError(masjidId);
-    }
+    if (!confData) throw new MawaqitParseError(masjidId);
 
-    setToCache(masjidId, confData);
+    setToCache(`conf:${masjidId}`, confData);
     return confData;
 }
 
+async function fetchMosquesByCountry(countryCode) {
+    const code = countryCode.toUpperCase();
+    const cacheKey = `map:${code}`;
+    const cached = getFromCache(cacheKey);
+    if (cached) return cached;
+
+    const url = `${BASE_API}/mosque/map/${code}`;
+
+    try {
+        const { data } = await axios.get(url);
+        setToCache(cacheKey, data, MAP_CACHE_TTL);
+        return data;
+    } catch {
+        throw new MawaqitCountryError(code);
+    }
+}
+
+async function fetchSearchMosques(word, fields) {
+    const cacheKey = `search:${word}:${fields || ""}`;
+    const cached = getFromCache(cacheKey);
+    if (cached) return cached;
+
+    const params = { word };
+    if (fields) params.fields = fields;
+
+    const url = `${BASE_API}/mosque/search`;
+
+    try {
+        const { data } = await axios.get(url, { params });
+        setToCache(cacheKey, data, SEARCH_CACHE_TTL);
+        return data;
+    } catch {
+        throw new MawaqitSearchError(word);
+    }
+}
+
 module.exports = {
-    fetchMawaqit
+    fetchMawaqit,
+    fetchMosquesByCountry,
+    fetchSearchMosques,
 };

package/dist/index.js

@@ -1,20 +1,43 @@
-const {
-    fetchMawaqit
-} = require("./fetch");
+const { fetchMawaqit, fetchMosquesByCountry, fetchSearchMosques } = require("./fetch");
 
 const {
     getPrayerTimesOfTheDay,
+    getIqamaTimes,
+    getNextPrayer,
+    getJumuaTimes,
     getCalendar,
     getMonth,
+    getDay,
     getMonthIqama,
     getAnnouncements,
     getServices,
+    getMosqueInfo,
+    getFlashMessage,
+    getRawConfData,
+    getMosquesByCountry,
+    getMosquesByCountryCount,
+    getMosquesByCity,
+    getMosquesByZipcode,
+    getMosquesByName,
+    getMosquesByRadius,
+    getNearestMosque,
+    getNearestMosques,
+    searchMosques,
+    searchByName,
+    searchByZipcode,
+    searchByCity,
+    searchFull,
+    searchWithTimes,
+    getAllCountryMosquesWithTimes,
+    getMultipleMosqueTimes,
 } = require("./mawaqit");
 
 const {
     clearCache,
     deleteCacheEntry,
     getCacheSize,
+    getCacheKeys,
+    hasCache,
 } = require("./cache");
 
 const {
@@ -23,26 +46,59 @@ const {
     MawaqitParseError,
     MawaqitFetchError,
     MawaqitValidationError,
+    MawaqitSearchError,
+    MawaqitCountryError,
 } = require("./errors");
 
 module.exports = {
     fetchMawaqit,
+    fetchMosquesByCountry,
+    fetchSearchMosques,
 
     getPrayerTimesOfTheDay,
+    getIqamaTimes,
+    getNextPrayer,
+    getJumuaTimes,
     getCalendar,
     getMonth,
+    getDay,
     getMonthIqama,
-
     getAnnouncements,
     getServices,
+    getMosqueInfo,
+    getFlashMessage,
+    getRawConfData,
+
+    getMosquesByCountry,
+    getMosquesByCountryCount,
+    getMosquesByCity,
+    getMosquesByZipcode,
+    getMosquesByName,
+    getMosquesByRadius,
+    getNearestMosque,
+    getNearestMosques,
+
+    searchMosques,
+    searchByName,
+    searchByZipcode,
+    searchByCity,
+    searchFull,
+    searchWithTimes,
+
+    getAllCountryMosquesWithTimes,
+    getMultipleMosqueTimes,
 
     clearCache,
     deleteCacheEntry,
     getCacheSize,
+    getCacheKeys,
+    hasCache,
 
     MawaqitError,
     MawaqitNotFoundError,
     MawaqitParseError,
     MawaqitFetchError,
     MawaqitValidationError,
+    MawaqitSearchError,
+    MawaqitCountryError,
 };

package/dist/mawaqit.js

@@ -1,15 +1,8 @@
-const {
-    fetchMawaqit
-} = require("./fetch");
-const {
-    MawaqitValidationError
-} = require("./errors");
+const { fetchMawaqit, fetchMosquesByCountry, fetchSearchMosques } = require("./fetch");
+const { MawaqitValidationError } = require("./errors");
 
 async function getPrayerTimesOfTheDay(masjidId) {
-    const {
-        times,
-        shuruq
-    } = await fetchMawaqit(masjidId);
+    const { times, shuruq } = await fetchMawaqit(masjidId);
     return {
         fajr: times[0],
         sunrise: shuruq,
@@ -20,10 +13,50 @@ async function getPrayerTimesOfTheDay(masjidId) {
     };
 }
 
+async function getIqamaTimes(masjidId) {
+    const { iqamaCalendar, iqamaEnabled } = await fetchMawaqit(masjidId);
+    if (!iqamaEnabled) return null;
+    const now = new Date();
+    const month = iqamaCalendar[now.getMonth()];
+    const day = Object.values(month)[now.getDate() - 1];
+    if (!day) return null;
+    return {
+        fajr: day[0],
+        dohr: day[1],
+        asr: day[2],
+        maghreb: day[3],
+        icha: day[4],
+    };
+}
+
+async function getNextPrayer(masjidId) {
+    const times = await getPrayerTimesOfTheDay(masjidId);
+    const now = new Date();
+    const nowMinutes = now.getHours() * 60 + now.getMinutes();
+    const names = ["fajr", "sunrise", "dohr", "asr", "maghreb", "icha"];
+
+    for (const name of names) {
+        const t = times[name];
+        if (!t) continue;
+        const [h, m] = t.split(":").map(Number);
+        if (h * 60 + m > nowMinutes) {
+            return { name, time: t };
+        }
+    }
+    return { name: "fajr", time: times.fajr, tomorrow: true };
+}
+
+async function getJumuaTimes(masjidId) {
+    const conf = await fetchMawaqit(masjidId);
+    const result = { jumua: conf.jumpiua || conf.jumua || null };
+    if (conf.jumua2) result.jumua2 = conf.jumua2;
+    if (conf.jumua3) result.jumua3 = conf.jumua3;
+    result.jumuaAsDuhr = conf.jumuaAsDuhr || false;
+    return result;
+}
+
 async function getCalendar(masjidId) {
-    const {
-        calendar
-    } = await fetchMawaqit(masjidId);
+    const { calendar } = await fetchMawaqit(masjidId);
     return calendar;
 }
 
@@ -31,9 +64,7 @@ async function getMonth(masjidId, monthNumber) {
     if (monthNumber < 1 || monthNumber > 12) {
         throw new MawaqitValidationError("Month number should be between 1 and 12");
     }
-    const {
-        calendar
-    } = await fetchMawaqit(masjidId);
+    const { calendar } = await fetchMawaqit(masjidId);
     const month = calendar[monthNumber - 1];
     return Object.values(month).map((prayer) => ({
         fajr: prayer[0],
@@ -45,13 +76,35 @@ async function getMonth(masjidId, monthNumber) {
     }));
 }
 
+async function getDay(masjidId, monthNumber, dayNumber) {
+    if (monthNumber < 1 || monthNumber > 12) {
+        throw new MawaqitValidationError("Month number should be between 1 and 12");
+    }
+    if (dayNumber < 1 || dayNumber > 31) {
+        throw new MawaqitValidationError("Day number should be between 1 and 31");
+    }
+    const { calendar } = await fetchMawaqit(masjidId);
+    const month = calendar[monthNumber - 1];
+    const days = Object.values(month);
+    if (dayNumber > days.length) {
+        throw new MawaqitValidationError(`Day ${dayNumber} does not exist in month ${monthNumber}`);
+    }
+    const prayer = days[dayNumber - 1];
+    return {
+        fajr: prayer[0],
+        sunrise: prayer[1],
+        dohr: prayer[2],
+        asr: prayer[3],
+        maghreb: prayer[4],
+        icha: prayer[5],
+    };
+}
+
 async function getMonthIqama(masjidId, monthNumber) {
     if (monthNumber < 1 || monthNumber > 12) {
         throw new MawaqitValidationError("Month number should be between 1 and 12");
     }
-    const {
-        iqamaCalendar
-    } = await fetchMawaqit(masjidId);
+    const { iqamaCalendar } = await fetchMawaqit(masjidId);
     const month = iqamaCalendar[monthNumber - 1];
     return Object.values(month).map((iqama) => ({
         fajr: iqama[0],
@@ -63,31 +116,237 @@ async function getMonthIqama(masjidId, monthNumber) {
 }
 
 async function getAnnouncements(masjidId) {
-    const {
-        announcements
-    } = await fetchMawaqit(masjidId);
+    const { announcements } = await fetchMawaqit(masjidId);
     return announcements ?? [];
 }
 
 async function getServices(masjidId) {
-    const confData = await fetchMawaqit(masjidId);
+    const conf = await fetchMawaqit(masjidId);
     return {
-        name: confData.name,
-        label: confData.label,
-        localisation: confData.localisation,
-        phone: confData.phone,
-        email: confData.email,
-        site: confData.site,
-        mosqueeType: confData.mosqueeType,
-        association: confData.association,
+        name: conf.name,
+        label: conf.label,
+        localisation: conf.localisation,
+        phone: conf.phone,
+        email: conf.email,
+        site: conf.site,
+        mosqueeType: conf.mosqueeType,
+        association: conf.association,
     };
 }
 
+async function getMosqueInfo(masjidId) {
+    const conf = await fetchMawaqit(masjidId);
+    return {
+        uuid: conf.uuid,
+        name: conf.name,
+        label: conf.label,
+        slug: masjidId,
+        localisation: conf.localisation,
+        phone: conf.phone,
+        email: conf.email,
+        site: conf.site,
+        mosqueeType: conf.mosqueeType,
+        association: conf.association,
+        image: conf.image1 || conf.image || null,
+        womenSpace: conf.womenSpace ?? null,
+        janazaPrayer: conf.janazaPrayer ?? null,
+        aidPrayer: conf.aidPrayer ?? null,
+        childrenCourses: conf.childrenCourses ?? null,
+        adultCourses: conf.adultCourses ?? null,
+        ramadanMeal: conf.ramadanMeal ?? null,
+        handicapAccessibility: conf.handicapAccessibility ?? null,
+        ablutions: conf.ablutions ?? null,
+        parking: conf.parking ?? null,
+        iqamaEnabled: conf.iqamaEnabled ?? false,
+        longitude: conf.longitude ?? null,
+        latitude: conf.latitude ?? null,
+    };
+}
+
+async function getFlashMessage(masjidId) {
+    const { flash } = await fetchMawaqit(masjidId);
+    return flash ?? null;
+}
+
+async function getRawConfData(masjidId) {
+    return await fetchMawaqit(masjidId);
+}
+
+// ---- Country / Map ----
+
+async function getMosquesByCountry(countryCode) {
+    if (!countryCode || countryCode.length !== 2) {
+        throw new MawaqitValidationError("Country code must be a 2-letter ISO code (e.g. FR, EN, DE)");
+    }
+    return await fetchMosquesByCountry(countryCode);
+}
+
+async function getMosquesByCountryCount(countryCode) {
+    const mosques = await getMosquesByCountry(countryCode);
+    return mosques.length;
+}
+
+async function getMosquesByCity(countryCode, city) {
+    const mosques = await getMosquesByCountry(countryCode);
+    const lower = city.toLowerCase();
+    return mosques.filter((m) => m.city && m.city.toLowerCase() === lower);
+}
+
+async function getMosquesByZipcode(countryCode, zipcode) {
+    const mosques = await getMosquesByCountry(countryCode);
+    return mosques.filter((m) => m.zipcode === zipcode);
+}
+
+async function getMosquesByName(countryCode, name) {
+    const mosques = await getMosquesByCountry(countryCode);
+    const lower = name.toLowerCase();
+    return mosques.filter((m) => m.name && m.name.toLowerCase().includes(lower));
+}
+
+async function getMosquesByRadius(countryCode, lat, lng, radiusKm) {
+    if (typeof lat !== "number" || typeof lng !== "number" || typeof radiusKm !== "number") {
+        throw new MawaqitValidationError("lat, lng and radiusKm must be numbers");
+    }
+    const mosques = await getMosquesByCountry(countryCode);
+    return mosques.filter((m) => {
+        if (!m.lat || !m.lng) return false;
+        const dist = haversine(lat, lng, m.lat, m.lng);
+        return dist <= radiusKm;
+    }).map((m) => ({
+        ...m,
+        distance: Math.round(haversine(lat, lng, m.lat, m.lng) * 100) / 100,
+    })).sort((a, b) => a.distance - b.distance);
+}
+
+async function getNearestMosque(countryCode, lat, lng) {
+    const mosques = await getMosquesByRadius(countryCode, lat, lng, 50000);
+    return mosques[0] || null;
+}
+
+async function getNearestMosques(countryCode, lat, lng, limit = 5) {
+    const mosques = await getMosquesByRadius(countryCode, lat, lng, 50000);
+    return mosques.slice(0, limit);
+}
+
+// ---- Search ----
+
+async function searchMosques(word, fields) {
+    if (!word || word.trim().length === 0) {
+        throw new MawaqitValidationError("Search word cannot be empty");
+    }
+    return await fetchSearchMosques(word.trim(), fields);
+}
+
+async function searchByName(name) {
+    return await searchMosques(name, "slug,label");
+}
+
+async function searchByZipcode(zipcode) {
+    return await searchMosques(zipcode, "slug,label");
+}
+
+async function searchByCity(city) {
+    return await searchMosques(city, "slug,label");
+}
+
+async function searchFull(word) {
+    return await searchMosques(word);
+}
+
+async function searchWithTimes(word) {
+    const results = await searchMosques(word);
+    return results.map((m) => ({
+        slug: m.slug,
+        name: m.name || m.label,
+        localisation: m.localisation,
+        times: m.times ? {
+            fajr: m.times[0],
+            sunrise: m.times[1],
+            dohr: m.times[2],
+            asr: m.times[3],
+            maghreb: m.times[4],
+            icha: m.times[5],
+        } : null,
+        iqama: m.iqama || null,
+        jumua: m.jumua || null,
+    }));
+}
+
+// ---- Bulk operations ----
+
+async function getAllCountryMosquesWithTimes(countryCode) {
+    const mosques = await getMosquesByCountry(countryCode);
+    const results = [];
+    for (const m of mosques) {
+        try {
+            const times = await getPrayerTimesOfTheDay(m.slug);
+            results.push({ ...m, times });
+        } catch {
+            results.push({ ...m, times: null });
+        }
+    }
+    return results;
+}
+
+async function getMultipleMosqueTimes(slugs) {
+    if (!Array.isArray(slugs)) {
+        throw new MawaqitValidationError("slugs must be an array");
+    }
+    const results = {};
+    for (const slug of slugs) {
+        try {
+            results[slug] = await getPrayerTimesOfTheDay(slug);
+        } catch (err) {
+            results[slug] = { error: err.message };
+        }
+    }
+    return results;
+}
+
+// ---- Utils ----
+
+function haversine(lat1, lon1, lat2, lon2) {
+    const R = 6371;
+    const dLat = (lat2 - lat1) * Math.PI / 180;
+    const dLon = (lon2 - lon1) * Math.PI / 180;
+    const a =
+        Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
+        Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
 module.exports = {
     getPrayerTimesOfTheDay,
+    getIqamaTimes,
+    getNextPrayer,
+    getJumuaTimes,
     getCalendar,
     getMonth,
+    getDay,
     getMonthIqama,
     getAnnouncements,
     getServices,
+    getMosqueInfo,
+    getFlashMessage,
+    getRawConfData,
+
+    getMosquesByCountry,
+    getMosquesByCountryCount,
+    getMosquesByCity,
+    getMosquesByZipcode,
+    getMosquesByName,
+    getMosquesByRadius,
+    getNearestMosque,
+    getNearestMosques,
+
+    searchMosques,
+    searchByName,
+    searchByZipcode,
+    searchByCity,
+    searchFull,
+    searchWithTimes,
+
+    getAllCountryMosquesWithTimes,
+    getMultipleMosqueTimes,
 };

package/package.json

@@ -1,35 +1,34 @@
-{
-  "name": "@max-xoo/mawaqit",
-  "version": "1.0.0",
-  "description": "A JavaScript wrapper around the unofficial Mawaqit API",
-  "keywords": [
-    "mawaqit",
-    "prayer",
-    "islam",
-    "mosque",
-    "salat",
-    "quran"
-  ],
-  "homepage": "https://github.com/roimee6/mawaqit#readme",
-  "bugs": {
-    "url": "https://github.com/roimee6/mawaqit/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/roimee6/mawaqit.git"
-  },
-  "license": "MIT",
-  "author": "Maxence",
-  "main": "dist/index.js",
-  "files": [
-    "dist/**/*"
-  ],
-  "scripts": {
-    "test": "node test.cjs"
-  },
-  "dependencies": {
-    "axios": "^1.13.5",
-    "cheerio": "^1.2.0"
-  },
-  "devDependencies": {}
-}
+{
+  "name": "@max-xoo/mawaqit",
+  "version": "1.5.0",
+  "description": "A JavaScript wrapper around the unofficial Mawaqit API",
+  "keywords": [
+    "mawaqit",
+    "prayer",
+    "islam",
+    "mosque",
+    "salat",
+    "quran"
+  ],
+  "homepage": "https://github.com/roimee6/mawaqit#readme",
+  "bugs": {
+    "url": "https://github.com/roimee6/mawaqit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/roimee6/mawaqit.git"
+  },
+  "license": "MIT",
+  "author": "Maxence",
+  "main": "dist/index.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "test": "node test.cjs"
+  },
+  "dependencies": {
+    "axios": "^1.13.5",
+    "cheerio": "^1.2.0"
+  }
+}