PrayTime

https://github.com/zarrabi/praytime
Admin
PrayTime is a JavaScript library designed for accurately calculating Islamic prayer times.
Tokens:5,232
Snippets:26
Trust Score:5.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Utilize Legacy getTimes Method

Source: https://context7.com/zarrabi/praytime/llms.txt

Provides examples of the legacy getTimes signature for backward compatibility, while contrasting it with the modern fluent API approach. Inputs include date arrays, coordinate pairs, and timezone offsets.

```javascript
const { PrayTime } = require('praytime');

const praytime = new PrayTime('ISNA');

// Legacy signature: getTimes(date, location, timezone, dst, format)
const date = [2025, 2, 21];
const coords = [43.4643, -80.5204];
const timezone = -5;  // UTC offset
const dst = 0;        // DST adjustment
const format = '12h';

const times = praytime.getTimes(date, coords, timezone, dst, format);

console.log(`Fajr: ${times.fajr}`);      // 3:32 PM format
console.log(`Maghrib: ${times.maghrib}`);

// Auto timezone detection
const autoTimes = praytime.getTimes(date, coords, 'auto', 0, '24h');
console.log('Auto timezone:', autoTimes);

// Modern approach (preferred)
const modernTimes = praytime
    .location(coords)
    .utcOffset(-5)
    .format('12h')
    .getTimes(date);
console.log('Modern API:', modernTimes);
```

--------------------------------

### Initialize PrayTime with Calculation Method and Get Times (JavaScript)

Source: https://context7.com/zarrabi/praytime/llms.txt

Initializes a PrayTime instance with a specified calculation method (e.g., 'ISNA', 'MWL') and configures location, timezone, and output format. It then retrieves and logs today's prayer times for the configured location.

```javascript
const { PrayTime } = require('praytime');

// Initialize with ISNA method
const praytime = new PrayTime('ISNA');

// Or use MWL (default)
const praytime2 = new PrayTime('MWL');

// Chain configuration methods
praytime
    .location([43.65, -79.4])  // Toronto coordinates [latitude, longitude]
    .timezone('America/Toronto')
    .format('24h');

// Get today's prayer times
const times = praytime.getTimes();
console.log(times);
// Output: {
//   fajr: '05:52',
//   sunrise: '07:18',
//   dhuhr: '12:36',
//   asr: '15:32',
//   sunset: '17:54',
//   maghrib: '18:02',
//   isha: '19:28',
//   midnight: '00:36'
// }
```

--------------------------------

### Get Prayer Times for Different Dates in JavaScript

Source: https://context7.com/zarrabi/praytime/llms.txt

Retrieves prayer times for specific dates using flexible input formats including day offsets, arrays, Date objects, or Unix timestamps. This allows for querying future, past, or present prayer schedules.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.65, -79.4]).timezone('America/Toronto');

// Get today's times (default)
const today = praytime.getTimes();
console.log('Today:', today.fajr);

// Get tomorrow's times (days offset)
const tomorrow = praytime.getTimes(1);
console.log('Tomorrow:', tomorrow.fajr);

// Get times 7 days from now
const nextWeek = praytime.getTimes(7);
console.log('Next week:', nextWeek.fajr);

// Get times for specific date [year, month, day]
const specific = praytime.getTimes([2025, 6, 15]);
console.log('June 15, 2025:', specific.fajr);

// Get times using Date object
const dateObj = new Date(2025, 5, 15);
const fromDate = praytime.getTimes(dateObj);
console.log('From Date object:', fromDate.fajr);

// Get times using Unix timestamp
const timestamp = Date.now();
const fromTimestamp = praytime.getTimes(timestamp);
console.log('From timestamp:', fromTimestamp.fajr);
```

--------------------------------

### Configure PrayTime with Method Chaining

Source: https://context7.com/zarrabi/praytime/llms.txt

Shows how to use method chaining for concise configuration in Node.js. Developers can adjust settings such as calculation methods, time rounding, and adjustments on the fly.

```javascript
const { PrayTime } = require('praytime');

// Complete configuration in one chain
const times = new PrayTime('Makkah')
    .location([21.4225, 39.8262])  // Makkah coordinates
    .timezone('Asia/Riyadh')
    .format('24h')
    .round('up')
    .adjust({ dhuhr: '5 min' })
    .tune({ maghrib: 2 })
    .getTimes([2025, 3, 15]);

console.log('Prayer times for Makkah:');
console.log(`Fajr: ${times.fajr}`);
console.log(`Dhuhr: ${times.dhuhr}`);
console.log(`Asr: ${times.asr}`);
console.log(`Maghrib: ${times.maghrib}`);
console.log(`Isha: ${times.isha}`);

// Switch methods on the fly
const praytime = new PrayTime('ISNA');
praytime.location([40.7128, -74.0060]).timezone('America/New_York');

// Calculate with ISNA method
const isnaTimes = praytime.getTimes();
console.log('ISNA Fajr:', isnaTimes.fajr);

// Switch to MWL method
praytime.method('MWL');
const mwlTimes = praytime.getTimes();
console.log('MWL Fajr:', mwlTimes.fajr);
```

--------------------------------

### Display Prayer Times in Browser

Source: https://context7.com/zarrabi/praytime/llms.txt

Demonstrates initializing the PrayTime library in an HTML environment to calculate and render prayer times for a specific location. It uses the fluent API to set coordinates and timezones, then outputs the results into a dynamic table.

```html
<!DOCTYPE html>
<html>
<head>
    <title>Prayer Times</title>
    <script src="praytime.js"></script>
</head>
<body>
    <h3>Toronto Prayer Times</h3>
    <div id="times"></div>

    <script>
        // Initialize PrayTime
        const praytime = new PrayTime('ISNA');

        // Set location for Toronto
        const coords = [43.65, -79.4];

        // Get prayer times
        const times = praytime
            .location(coords)
            .timezone('America/Toronto')
            .format('12h')
            .getTimes();

        // Display times
        const timesDiv = document.getElementById('times');
        const today = new Date().toLocaleDateString('en-US', {
            year: 'numeric',
            month: 'long',
            day: 'numeric'
        });

        timesDiv.innerHTML = `
            <table>
                <tr><th colspan="2">${today}</th></tr>
                <tr><td>Fajr</td><td>${times.fajr}</td></tr>
                <tr><td>Sunrise</td><td>${times.sunrise}</td></tr>
                <tr><td>Dhuhr</td><td>${times.dhuhr}</td></tr>
                <tr><td>Asr</td><td>${times.asr}</td></tr>
                <tr><td>Maghrib</td><td>${times.maghrib}</td></tr>
                <tr><td>Isha</td><td>${times.isha}</td></tr>
                <tr><td>Midnight</td><td>${times.midnight}</td></tr>
            </table>
        `;
    </script>
</body>
</html>
```

--------------------------------

### Format Output Prayer Times (JavaScript)

Source: https://context7.com/zarrabi/praytime/llms.txt

Illustrates various output formats for prayer times, including 24-hour, 12-hour (with/without AM/PM), Unix timestamps (seconds/milliseconds), and custom formats using a callback function.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.4643, -80.5204]).timezone('America/Toronto');

const date = [2025, 2, 21];

// 24-hour format (default)
praytime.format('24h');
console.log(praytime.getTimes(date).asr);  // 15:32

// 12-hour format with AM/PM
praytime.format('12h');
console.log(praytime.getTimes(date).asr);  // 3:32 PM

// 12-hour format without AM/PM
praytime.format('12H');
console.log(praytime.getTimes(date).asr);  // 3:32

// Unix timestamp in milliseconds
praytime.format('x');
console.log(praytime.getTimes(date).asr);  // 1740169920000

// Unix timestamp in seconds
praytime.format('X');
console.log(praytime.getTimes(date).asr);  // 1740169920

// Custom format function
praytime.format((timestamp) => {
    const date = new Date(timestamp);
    return date.toISOString();
});
console.log(praytime.getTimes(date).asr);  // ISO 8601 format
```

--------------------------------

### Configure UTC Offset for Prayer Times (JavaScript)

Source: https://context7.com/zarrabi/praytime/llms.txt

Demonstrates how to manually set the UTC offset for prayer time calculations using the `utcOffset` method, either in hours or minutes. It shows how changing the offset affects the calculated prayer times.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.4643, -80.5204]);

// Set UTC offset in hours
praytime.utcOffset(-5);  // -5 hours

// Or in minutes
praytime.utcOffset(-300);  // -300 minutes = -5 hours

// Get times
const times = praytime.getTimes([2025, 2, 21]);
console.log(times.fajr);  // 05:52

// Different offset
praytime.utcOffset(-4.5);
const times2 = praytime.getTimes([2025, 2, 21]);
console.log(times2.fajr);  // 06:22
```

--------------------------------

### Initialize and Display Prayer Times Table

Source: https://github.com/zarrabi/praytime/blob/main/examples/monthly.html

Functions to configure the PrayTime library, manage month navigation, and dynamically generate an HTML table containing daily prayer schedules. It calculates times based on location, timezone, and selected calculation method.

```javascript
const praytime = new PrayTime();
const currentDate = new Date();
let timeFormat = 1;

function displayMonth(offset) {
  const lat = $('#latitude').value;
  const lng = $('#longitude').value;
  const timezone = $('#timezone').value;
  const method = $('#method').value;
  const format = timeFormat ? '12H' : '24h';
  
  praytime.method(method).location([lat, lng]).timezone(timezone).format(format);
  currentDate.setMonth(currentDate.getMonth() + offset);
  const month = currentDate.getMonth();
  const year = currentDate.getFullYear();
  const monthName = currentDate.toLocaleString('en-US', { year: 'numeric', month: 'long' });
  $('#table-title').innerHTML = monthName;
  makeTable(year, month, timezone);
}

function makeTable(year, month, timezone) {
  const items = { day: 'Day', fajr: 'Fajr', sunrise: 'Sunrise', dhuhr: 'Dhuhr', asr: 'Asr', maghrib: 'Maghrib', isha: 'Isha' };
  const tbody = document.createElement('tbody');
  tbody.appendChild(makeTableRow(items, items, 'head-row'));
  const date = new Date(year, month, 1);
  const endDate = new Date(year, month + 1, 1);
  while (date < endDate) {
    const times = praytime.getTimes(date);
    times.day = date.getDate();
    const isToday = date.toDateString() === new Date().toDateString();
    const cls = isToday ? 'today-row' : '';
    tbody.appendChild(makeTableRow(times, items, cls));
    date.setDate(date.getDate() + 1);
  }
  $('#timetable').replaceChildren();
  $('#timetable').appendChild(tbody);
}
```

--------------------------------

### Configure Rounding Method in JavaScript

Source: https://context7.com/zarrabi/praytime/llms.txt

Sets the behavior for how calculated time values are rounded. Supports rounding to the nearest minute, forcing up or down rounding, or disabling rounding entirely to return exact timestamps.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.4643, -80.5204]).timezone('America/Toronto');

const date = [2025, 2, 21];

// Round to nearest minute (default)
praytime.round('nearest');
console.log(praytime.getTimes(date).asr);

// Always round up
praytime.round('up');
console.log(praytime.getTimes(date).asr);

// Always round down
praytime.round('down');
console.log(praytime.getTimes(date).asr);

// No rounding (returns exact timestamp)
praytime.round('none');
praytime.format('x');
console.log(praytime.getTimes(date).asr);
```

--------------------------------

### Tune Prayer Times with Offsets in JavaScript

Source: https://context7.com/zarrabi/praytime/llms.txt

Applies static minute-based offsets to specific prayer times to meet local requirements or mosque-specific adjustments. These adjustments are additive to the calculated results without altering the underlying mathematical angles.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.4643, -80.5204]).timezone('America/Toronto');

// Add/subtract minutes from specific prayer times
praytime.tune({
    fajr: 2,
    asr: 11,
    maghrib: 4.5,
    isha: -3
});

const times = praytime.getTimes([2025, 2, 21]);
console.log(times.asr);
console.log(times.maghrib);

// Tuning is useful for local mosque adjustments
praytime.tune({ fajr: 5, isha: 10 });
const localTimes = praytime.getTimes();
console.log('Local mosque times:', localTimes);
```

--------------------------------

### Initialize Timezone Select Menu

Source: https://github.com/zarrabi/praytime/blob/main/examples/monthly.html

Populates a dropdown menu with all supported timezones using the Intl API, defaulting to a specific geographic region.

```javascript
function initTimeZoneList() {
  const defaultZone = 'America/Toronto';
  const timezones = Intl.supportedValuesOf("timeZone") || [defaultZone];
  const selectElement = $('#timezone');
  timezones.forEach((timezone) => {
    const option = document.createElement('option');
    option.value = timezone;
    option.textContent = timezone;
    if (timezone === defaultZone) {
      option.selected = true;
    }
    selectElement.appendChild(option);
  });
}
```

--------------------------------

### Calculate and Render Prayer Times in JavaScript

Source: https://github.com/zarrabi/praytime/blob/main/examples/daily.html

This script initializes the PrayTime library with ISNA calculation settings, retrieves prayer times for Toronto coordinates, and generates an HTML table to display the schedule. It relies on the Intl.DateTimeFormat API for date formatting and injects the resulting markup into the DOM.

```javascript
const praytime = new PrayTime('ISNA');
const coords = [43.65, -79.4];
const times = praytime.location(coords).timezone('America/Toronto').getTimes();
const today = new Intl.DateTimeFormat("en-US", { year: "numeric", month: "long", day: "numeric" }).format();

document.getElementsByTagName('div')[0].innerHTML = `
  <table class="daily">
    <tr><th colspan="2">${today}</th></tr>
    ${['Fajr', 'Sunrise', 'Dhuhr', 'Asr', 'Maghrib', 'Isha'].map(label => `
      <tr><td>${label}</td><td>${times[label.toLowerCase()]}</td></tr>
    `).join('')}
  </table>
`;
```

--------------------------------

### Set Location and Timezone for Prayer Times (JavaScript)

Source: https://context7.com/zarrabi/praytime/llms.txt

Configures the PrayTime library with specific geographical coordinates and an IANA timezone identifier. It then calculates and logs prayer times for a given date, demonstrating the `location` and `timezone` methods.

```javascript
const praytime = new PrayTime('ISNA');

// Set location using coordinates
praytime.location([43.4643, -80.5204]);  // Waterloo, ON, Canada

// Set timezone string (IANA timezone identifier)
praytime.timezone('America/Toronto');

// Get times for specific date
const date = [2025, 2, 21];  // February 21, 2025
const times = praytime.getTimes(date);

console.log(`Fajr: ${times.fajr}`);      // Fajr: 05:52
console.log(`Dhuhr: ${times.dhuhr}`);    // Dhuhr: 12:36
console.log(`Asr: ${times.asr}`);        // Asr: 15:32
console.log(`Maghrib: ${times.maghrib}`);// Maghrib: 18:02
```

--------------------------------

### Adjust Calculation Parameters in JavaScript

Source: https://context7.com/zarrabi/praytime/llms.txt

Configures core calculation settings such as Fajr and Isha angles, Dhuhr and Maghrib offsets, and Asr calculation methods (e.g., Hanafi). This is used to align the base algorithm with specific regional or organizational standards.

```javascript
const praytime = new PrayTime('ISNA');
praytime.location([43.4643, -80.5204]).timezone('America/Toronto');

// Adjust Fajr angle and Dhuhr time
praytime.adjust({
    fajr: 19.7,
    dhuhr: '11 min',
    isha: 17,
    maghrib: '5 min'
});

const times = praytime.getTimes([2025, 2, 21]);
console.log(times.fajr);
console.log(times.dhuhr);

// Adjust Asr calculation method
praytime.adjust({ asr: 'Hanafi' });
const times2 = praytime.getTimes([2025, 2, 21]);
console.log(times2.asr);
```

--------------------------------

### JavaScript Prayer Timetable Calculation and Display

Source: https://github.com/zarrabi/praytime/blob/main/examples/yearly.html

This JavaScript code initializes a prayer time calculator, sets up event listeners for user input, and dynamically generates an HTML table displaying daily prayer times for a specified year. It utilizes the PrayTime library and DOM manipulation to render the timetable. Dependencies include the PrayTime library and standard browser APIs.

```javascript
const praytime = new PrayTime();
$('#year').value = (new Date()).getFullYear();
initTimeZoneList();
update();

function update() {
    const lat = $('#latitude').value;
    const lng = $('#longitude').value;
    const timezone = $('#timezone').value;
    const method = $('#method').value;
    const year = $('#year').value;

    // set prayer times parameters
    praytime.method(method).location([lat, lng]).timezone(timezone);

    $('#timetable').innerHTML = '<pre>' + makeTable(year) + '</pre>';
}

function makeTable(year) {
    const date = new Date(+year, 0, 1);
    const endDate = new Date(+year + 1, 0, 1);
    const labels = ['Fajr', 'Sunrise', 'Dhuhr', 'Asr', 'Maghrib', 'Isha'];
    let table = '';

    while (date < endDate) {
        const times = praytime.getTimes(date);
        // get prayer times
        const day = date.toLocaleString('en-US', { month: 'short', day: '2-digit' });
        table += day + '\t' + labels.map(label => times[label.toLowerCase()]).join('\t') + '\n';
        date.setDate(date.getDate() + 1); // next day
    }
    return table;
}

function initTimeZoneList() {
    const defaultZone = 'America/Toronto';
    const timezones = Intl.supportedValuesOf("timeZone") || [defaultZone];
    const selectElement = $('#timezone');

    timezones.forEach((timezone) => {
        const option = document.createElement('option');
        option.value = timezone;
        option.textContent = timezone;
        if (timezone === defaultZone) {
            option.selected = true;
        }
        selectElement.appendChild(option);
    });
}

function $(selector) {
    return document.querySelector(selector);
}
```
Tokens:
Raw