Croner

// Basic: Run a function at the interval defined by a cron expression
const job = Cron('*/5 * * * * *', () => {
    console.log('This will run every fifth second');
});

// Enumeration: What dates do the next 100 sundays occur at?
const nextSundays = Cron('0 0 0 * * 7').enumerate(100);
console.log(nextSundays);

// Days left to a specific date
const msLeft = Cron('59 59 23 24 DEC *').next() - new Date();
console.log(Math.floor(msLeft/1000/3600/24) + " days left to next christmas eve");

// Run a function at a specific date/time using a non-local timezone (time is ISO 8601 local time)
// This will run 2023-01-23 00:00:00 according to the time in Asia/Kolkata
Cron('2023-01-23T00:00:00', { timezone: 'Asia/Kolkata' }, () => { console.log('Yay') });

// ESM Import ...
import Cron from "croner";

// ... or CommonJS Require
const Cron = require("croner");

import Cron from "croner";

import Cron from "https://deno.land/x/croner@5.6.1/src/croner.js";

Cron("* * * * * *", () => {
    console.log("This will run every second.");
});

const job = Cron("* * * * * *" /* Or a date object, or ISO 8601 local time */ , /*optional*/ { maxRuns: 1 } , /*optional*/ () => {} );

// If function is omitted in constructor, it can be scheduled later
job.schedule((/* optional */ job, /* optional */ context) => {});		

// States
const nextRun = job.next( /*optional*/ previousRun );	// Get a Date object representing next run
const nextRuns = job.enumerate(10, /*optional*/ startFrom ); // Get a array of Dates, containing next 10 runs according to pattern
const prevRun = job.previous( );	
const msToNext = job.msToNext( /*optional*/ previousRun ); // Milliseconds left to next execution
const isRunning = job.running();

// Control scheduled execution
job.pause();				
job.resume();
job.stop();

// ┌──────────────── (optional) second (0 - 59)
// │ ┌────────────── minute (0 - 59)
// │ │ ┌──────────── hour (0 - 23)
// │ │ │ ┌────────── day of month (1 - 31)
// │ │ │ │ ┌──────── month (1 - 12, JAN-DEC)
// │ │ │ │ │ ┌────── day of week (0 - 6, SUN-Mon) 
// │ │ │ │ │ │       (0 to 6 are Sunday to Saturday; 7 is Sunday, the same as 0)
// │ │ │ │ │ │
// * * * * * *

// Run a function according to pattern
Cron('15-45/10 */5 1,2,3 ? JAN-MAR SAT', { legacyMode: false }, function () {
    console.log('This will run every tenth second between second 15-45');
    console.log('every fifth minute of hour 1,2 and 3 when day of month');
    console.log('is the same as when Cron started, every saturday in January to March.');
});

// Trigger on specific interval combined with cron expression
Cron('* * * 7-16 * MON-FRI', { interval: 90, legacyMode: false }, function () {
    console.log('This will trigger every 90th second at 7-16 on mondays to fridays.');
});

// Find next month
const nextMonth = Cron("@monthly").next(),
    nextSunday = Cron("@weekly").next(),
    nextSat29feb = Cron("0 0 0 29 2 6", { legacyMode: false }).next(),
    nextSunLastOfMonth = Cron("0 0 0 L * 7", { legacyMode: false }).next();

console.log("First day of next month: " +  nextMonth.toLocaleDateString());
console.log("Next sunday: " +  nextSunday.toLocaleDateString());
console.log("Next saturday at 29th of february: " +  nextSat29feb.toLocaleDateString());  // 2048-02-29
console.log("Next month ending with a sunday: " +  nextSunLastOfMonth.toLocaleDateString()); 

const job = Cron(
    '* * * * *', 
    { 
        maxRuns: Infinity, 
        startAt: "2021-11-01T00:00:00", 
        stopAt: "2021-12-01T00:00:00",
        timezone: "Europe/Stockholm"
    },
    function() {
        console.log('This will run every minute, from 2021-11-01 to 2021-12-01 00:00:00');
    }
);

const job = Cron('* * * * * *', (self) => {
    console.log('This will run every second. Pause on second 10. Resume on 15. And quit on 20.');
    console.log('Current second: ', new Date().getSeconds());
    console.log('Previous run: ' + self.previous());
    console.log('Next run: ' + self.next());
});

Cron('10 * * * * *', {maxRuns: 1}, () => job.pause());
Cron('15 * * * * *', {maxRuns: 1}, () => job.resume());
Cron('20 * * * * *', {maxRuns: 1}, () => job.stop());

const data = {
    what: "stuff"
};

Cron('* * * * * *', { context: data }, (_self, context) => {
    console.log('This will print stuff: ' + context.what);
});

Cron('*/5 * * * * *', { context: data }, (self, context) => {
    console.log('After this, other stuff will be printed instead');
    context.what = "other stuff";
    self.stop();
});

// A javascript date, or a ISO 8601 local time string can be passed, to fire a function once. 
// Always specify which timezone the ISO 8601 time string has with the timezone option.
let job = Cron("2025-01-01T23:00:00",{timezone: "Europe/Stockholm"},() => {
    console.log('This will run at 2025-01-01 23:00:00 in timezone Europe/Stockholm');
});

if (job.next() === null) {
    // The job will not fire for some reason
} else {
    console.log("Job will fire at " + job.next());
}

// import { Cron, scheduledJobs } ...

// Scoped job
(() => {

    // As we specify a name for the job, a reference will be kept in `scheduledJobs`
    const job = Cron("* * * * * *", { name: "Job1" }, function () {
        console.log("This will run every second");
    });

    job.pause();
    console.log("Job paused");

})();

// Another scope, delayed 5 seconds
setTimeout(() => {

    // Find our job
    // - scheduledJobs can either be imported separately { Cron, scheduledJobs }
    //   or access through Cron.scheduledJobs
    const job = scheduledJobs.find(j => j.name === "Job1");

    // Resume it
    if (job) {
        if(job.resume()) {
            // This will happen
            console.log("Job resumed successfully");
        } else {
            console.log("Job found, but could not be restarted. The job were probably stopped using `.stop()` which prevents resuming.");
        }
    } else {
        console.error("Job not found");
    }

}, 5000);

// Start a job firing once each 5th second, run at most 3 times
const job = new Cron("0/5 * * * * *", { maxRuns: 3 }, (job) => {
    
    // Do work
    console.log('Job Running');

    // Is this the last execution?
    if (!job.next()) {
        console.log('Last execution');
    }

});
 
// Will there be no executions? 
// This would trigger if you change maxRuns to 0, or manage to compose 
// an impossible cron expression.
if (!job.next() && !job.previous()) {
    console.log('No executions scheduled');
}