@stacksjs/scheduler 0.58.51 → 0.58.52

package/dist/index.js

@@ -1,209 +1,739 @@
 // @bun
-// src/index.ts
-import cron from "node-cron";
-function run(callback) {
-  return {
-    everySecond: () => {
-      cron.schedule("* * * * * *", callback);
-    },
-    everySeconds: (seconds = 1) => {
-      cron.schedule(`*/${seconds} * * * * *`, callback);
-    },
-    everyMinute: () => {
-      cron.schedule("* * * * *", callback);
-    },
-    everyTwoMinutes: () => {
-      cron.schedule("*/2 * * * *", callback);
-    },
-    everyThreeMinutes: () => {
-      cron.schedule("*/3 * * * *", callback);
-    },
-    everyFourMinutes: () => {
-      cron.schedule("*/4 * * * *", callback);
-    },
-    everyFiveMinutes: () => {
-      cron.schedule("*/5 * * * *", callback);
-    },
-    everyTenMinutes: () => {
-      cron.schedule("*/10 * * * *", callback);
-    },
-    everyFifteenMinutes: () => {
-      cron.schedule("*/15 * * * *", callback);
-    },
-    everyThirtyMinutes: () => {
-      cron.schedule("*/30 * * * *", callback);
-    },
-    everyMinutes: (minutes) => {
-      cron.schedule(`*/${minutes} * * * *`, callback);
-    },
-    hourly: () => {
-      cron.schedule("0 * * * *", callback);
-    },
-    everyHours: (hours) => {
-      cron.schedule(`0 */${hours} * * *`, callback);
-    },
-    hourlyAt: (minute) => {
-      cron.schedule(`${minute} * * * *`, callback);
-    },
-    everyOddHour: () => {
-      cron.schedule("0 */2 * * *", callback);
-    },
-    everyTwoHours: () => {
-      cron.schedule("0 */2 * * *", callback);
-    },
-    everyThreeHours: () => {
-      cron.schedule("0 */3 * * *", callback);
-    },
-    everyFourHours: () => {
-      cron.schedule("0 */4 * * *", callback);
-    },
-    everySixHours: () => {
-      cron.schedule("0 */6 * * *", callback);
-    },
-    dailyAt: (hour, minute) => {
-      cron.schedule(`${minute} ${hour} * * *`, callback);
-    },
-    daily: () => {
-      cron.schedule("0 0 * * *", callback);
-    },
-    everyDays: (days) => {
-      cron.schedule(`0 0 */${days} * *`, callback);
-    },
-    weekly: () => {
-      cron.schedule("0 0 * * 0", callback);
-    },
-    quarterly: () => {
-      cron.schedule("0 0 1 */3 *", callback);
-    },
-    yearly: () => {
-      cron.schedule("0 0 1 1 *", callback);
-    },
-    cron: (interval, timezone) => {
-      timezone ? cron.schedule(interval, callback, { scheduled: true, timezone }) : cron.schedule(interval, callback);
-    }
-  };
+// src/schedule.ts
+import {log} from "@stacksjs/cli";
+
+// src/time.ts
+import {DateTime} from "luxon";
+
+// src/constants.ts
+var CONSTRAINTS = Object.freeze({
+  second: [0, 59],
+  minute: [0, 59],
+  hour: [0, 23],
+  dayOfMonth: [1, 31],
+  month: [1, 12],
+  dayOfWeek: [0, 7]
+});
+var MONTH_CONSTRAINTS = Object.freeze({
+  1: 31,
+  2: 29,
+  3: 31,
+  4: 30,
+  5: 31,
+  6: 30,
+  7: 31,
+  8: 31,
+  9: 30,
+  10: 31,
+  11: 30,
+  12: 31
+});
+var PARSE_DEFAULTS = Object.freeze({
+  second: "0",
+  minute: "*",
+  hour: "*",
+  dayOfMonth: "*",
+  month: "*",
+  dayOfWeek: "*"
+});
+var ALIASES = Object.freeze({
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12,
+  sun: 0,
+  mon: 1,
+  tue: 2,
+  wed: 3,
+  thu: 4,
+  fri: 5,
+  sat: 6
+});
+var TIME_UNITS_MAP = Object.freeze({
+  SECOND: "second",
+  MINUTE: "minute",
+  HOUR: "hour",
+  DAY_OF_MONTH: "dayOfMonth",
+  MONTH: "month",
+  DAY_OF_WEEK: "dayOfWeek"
+});
+var TIME_UNITS = Object.freeze(Object.values(TIME_UNITS_MAP));
+var TIME_UNITS_LEN = TIME_UNITS.length;
+var PRESETS = Object.freeze({
+  "@yearly": "0 0 0 1 1 *",
+  "@monthly": "0 0 0 1 * *",
+  "@weekly": "0 0 0 * * 0",
+  "@daily": "0 0 0 * * *",
+  "@hourly": "0 0 * * * *",
+  "@minutely": "0 * * * * *",
+  "@secondly": "* * * * * *",
+  "@weekdays": "0 0 0 * * 1-5",
+  "@weekends": "0 0 0 * * 0,6"
+});
+var RE_WILDCARDS = /\*/g;
+var RE_RANGE = /^(\d+)(?:-(\d+))?(?:\/(\d+))?$/g;
+
+// src/errors.ts
+class CronError extends Error {
+  constructor() {
+    super(...arguments);
+  }
 }
-function useScheduler() {
-  return {
-    run
-  };
+
+class ExclusiveParametersError extends CronError {
+  constructor(param1, param2) {
+    super(`You can't specify both ${param1} and ${param2}`);
+  }
 }
 
-class ScheduleImpl {
-  actionName = "";
-  commandName = "";
-  jobName = "";
-  execName = "";
-  callback = () => {
-  };
-  whenCallback = () => true;
-  startTime = "";
-  endTime = "";
-  timezoneName = "";
-  time = "";
-  action(action) {
-    this.actionName = action;
-    return this;
+// src/utils.ts
+function getRecordKeys(record) {
+  return Object.keys(record);
+}
+function getTimeZoneAndOffset(timeZone, utcOffset) {
+  if (timeZone != null && utcOffset != null)
+    throw new ExclusiveParametersError("timeZone", "utcOffset");
+  if (timeZone != null)
+    return { timeZone, utcOffset: null };
+  if (utcOffset != null)
+    return { timeZone: null, utcOffset };
+  return { timeZone: null, utcOffset: null };
+}
+
+// src/time.ts
+class CronTime {
+  source;
+  timeZone;
+  utcOffset;
+  realDate = false;
+  second = {};
+  minute = {};
+  hour = {};
+  dayOfMonth = {};
+  month = {};
+  dayOfWeek = {};
+  constructor(source, timeZone, utcOffset) {
+    if (timeZone != null && utcOffset != null)
+      throw new ExclusiveParametersError("timeZone", "utcOffset");
+    if (timeZone) {
+      const dt = DateTime.fromObject({}, { zone: timeZone });
+      if (!dt.isValid)
+        throw new CronError("Invalid timezone.");
+      this.timeZone = timeZone;
+    }
+    if (utcOffset != null)
+      this.utcOffset = utcOffset;
+    if (source instanceof Date || source instanceof DateTime) {
+      this.source = source instanceof Date ? DateTime.fromJSDate(source) : source;
+      this.realDate = true;
+    } else {
+      this.source = source;
+      this._parse(this.source);
+      this._verifyParse();
+    }
   }
-  command(cmd) {
-    this.commandName = cmd;
-    return this;
+  _getWeekDay(date) {
+    return date.weekday === 7 ? 0 : date.weekday;
   }
-  job(job) {
-    this.jobName = job;
-    return this;
+  _verifyParse() {
+    const months = getRecordKeys(this.month);
+    const daysOfMonth = getRecordKeys(this.dayOfMonth);
+    let isOk = false;
+    let lastWrongMonth = null;
+    for (const m of months) {
+      const con = MONTH_CONSTRAINTS[m];
+      for (const day of daysOfMonth) {
+        if (day <= con)
+          isOk = true;
+      }
+      if (!isOk) {
+        lastWrongMonth = m;
+        console.warn(`Month '${m}' is limited to '${con}' days.`);
+      }
+    }
+    if (!isOk && lastWrongMonth !== null) {
+      const notOkCon = MONTH_CONSTRAINTS[lastWrongMonth];
+      for (const notOkDay of daysOfMonth) {
+        if (notOkDay > notOkCon) {
+          delete this.dayOfMonth[notOkDay];
+          const fixedDay = notOkDay % notOkCon;
+          this.dayOfMonth[fixedDay] = true;
+        }
+      }
+    }
   }
-  exec(cmd) {
-    this.execName = cmd;
-    return this;
+  sendAt(i) {
+    let date = this.realDate && this.source instanceof DateTime ? this.source : DateTime.local();
+    if (this.timeZone)
+      date = date.setZone(this.timeZone);
+    if (this.utcOffset !== undefined) {
+      const sign = this.utcOffset < 0 ? "-" : "+";
+      const offsetHours = Math.trunc(this.utcOffset / 60);
+      const offsetHoursStr = String(Math.abs(offsetHours)).padStart(2, "0");
+      const offsetMins = Math.abs(this.utcOffset - offsetHours * 60);
+      const offsetMinsStr = String(offsetMins).padStart(2, "0");
+      const utcZone = `UTC${sign}${offsetHoursStr}:${offsetMinsStr}`;
+      date = date.setZone(utcZone);
+      if (!date.isValid)
+        throw new CronError("ERROR: You specified an invalid UTC offset.");
+    }
+    if (this.realDate) {
+      if (DateTime.local() > date)
+        throw new CronError("WARNING: Date in past. Will never be fired.");
+      return date;
+    }
+    if (i === undefined || Number.isNaN(i) || i < 0) {
+      return this.getNextDateFrom(date);
+    } else {
+      const dates = [];
+      for (;i > 0; i--) {
+        date = this.getNextDateFrom(date);
+        dates.push(date);
+      }
+      return dates;
+    }
   }
-  call(callback) {
-    this.callback = callback;
-    return this;
+  getTimeout() {
+    return Math.max(-1, this.sendAt().toMillis() - DateTime.local().toMillis());
   }
-  everyMinute() {
-    return this;
+  toString() {
+    return this.toJSON().join(" ");
+  }
+  toJSON() {
+    return TIME_UNITS.map((unit) => {
+      return this._wcOrAll(unit);
+    });
+  }
+  getNextDateFrom(start, timeZone) {
+    if (start instanceof Date)
+      start = DateTime.fromJSDate(start);
+    let date = start;
+    const firstDate = start.toMillis();
+    if (timeZone)
+      date = date.setZone(timeZone);
+    if (!this.realDate) {
+      if (date.millisecond > 0)
+        date = date.set({ millisecond: 0, second: date.second + 1 });
+    }
+    if (!date.isValid)
+      throw new CronError("ERROR: You specified an invalid date.");
+    const maxMatch = DateTime.now().plus({ years: 8 });
+    while (true) {
+      const diff = date.toMillis() - start.toMillis();
+      if (date > maxMatch) {
+        throw new CronError(`Something went wrong. No execution date was found in the next 8 years.
+              Please provide the following string if you would like to help debug:
+              Time Zone: ${timeZone?.toString() ?? '""'} - Cron String: ${this.source.toString()} - UTC offset: ${date.offset} - current Date: ${DateTime.local().toString()}`);
+      }
+      if (!(date.month in this.month) && Object.keys(this.month).length !== 12) {
+        date = date.plus({ months: 1 });
+        date = date.set({ day: 1, hour: 0, minute: 0, second: 0 });
+        if (this._forwardDSTJump(0, 0, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (!(date.day in this.dayOfMonth) && Object.keys(this.dayOfMonth).length !== 31 && !((this._getWeekDay(date) in this.dayOfWeek) && Object.keys(this.dayOfWeek).length !== 7)) {
+        date = date.plus({ days: 1 });
+        date = date.set({ hour: 0, minute: 0, second: 0 });
+        if (this._forwardDSTJump(0, 0, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (!(this._getWeekDay(date) in this.dayOfWeek) && Object.keys(this.dayOfWeek).length !== 7 && !((date.day in this.dayOfMonth) && Object.keys(this.dayOfMonth).length !== 31)) {
+        date = date.plus({ days: 1 });
+        date = date.set({ hour: 0, minute: 0, second: 0 });
+        if (this._forwardDSTJump(0, 0, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (!(date.hour in this.hour) && Object.keys(this.hour).length !== 24) {
+        const expectedHour = date.hour === 23 && diff > 86400000 ? 0 : date.hour + 1;
+        const expectedMinute = date.minute;
+        date = date.set({ hour: expectedHour });
+        date = date.set({ minute: 0, second: 0 });
+        if (this._forwardDSTJump(expectedHour, expectedMinute, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (!(date.minute in this.minute) && Object.keys(this.minute).length !== 60) {
+        const expectedMinute = date.minute === 59 && diff > 3600000 ? 0 : date.minute + 1;
+        const expectedHour = date.hour + (expectedMinute === 60 ? 1 : 0);
+        date = date.set({ minute: expectedMinute });
+        date = date.set({ second: 0 });
+        if (this._forwardDSTJump(expectedHour, expectedMinute, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (!(date.second in this.second) && Object.keys(this.second).length !== 60) {
+        const expectedSecond = date.second === 59 && diff > 60000 ? 0 : date.second + 1;
+        const expectedMinute = date.minute + (expectedSecond === 60 ? 1 : 0);
+        const expectedHour = date.hour + (expectedMinute === 60 ? 1 : 0);
+        date = date.set({ second: expectedSecond });
+        if (this._forwardDSTJump(expectedHour, expectedMinute, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      if (date.toMillis() === firstDate) {
+        const expectedSecond = date.second + 1;
+        const expectedMinute = date.minute + (expectedSecond === 60 ? 1 : 0);
+        const expectedHour = date.hour + (expectedMinute === 60 ? 1 : 0);
+        date = date.set({ second: expectedSecond });
+        if (this._forwardDSTJump(expectedHour, expectedMinute, date)) {
+          const [isDone, newDate] = this._findPreviousDSTJump(date);
+          date = newDate;
+          if (isDone)
+            break;
+        }
+        continue;
+      }
+      break;
+    }
+    return date;
+  }
+  _findPreviousDSTJump(date) {
+    let expectedMinute, expectedHour, actualMinute, actualHour;
+    let maybeJumpingPoint = date;
+    const iterationLimit = 1440;
+    let iteration = 0;
+    do {
+      if (++iteration > iterationLimit) {
+        throw new CronError(`ERROR: This DST checking related function assumes the input DateTime (${date.toISO() ?? date.toMillis()}) is within 24 hours of a DST jump.`);
+      }
+      expectedMinute = maybeJumpingPoint.minute - 1;
+      expectedHour = maybeJumpingPoint.hour;
+      if (expectedMinute < 0) {
+        expectedMinute += 60;
+        expectedHour = (expectedHour + 24 - 1) % 24;
+      }
+      maybeJumpingPoint = maybeJumpingPoint.minus({ minute: 1 });
+      actualMinute = maybeJumpingPoint.minute;
+      actualHour = maybeJumpingPoint.hour;
+    } while (expectedMinute === actualMinute && expectedHour === actualHour);
+    const afterJumpingPoint = maybeJumpingPoint.plus({ minute: 1 }).set({ second: 0, millisecond: 0 });
+    const beforeJumpingPoint = afterJumpingPoint.minus({ second: 1 });
+    if (date.month + 1 in this.month && date.day in this.dayOfMonth && this._getWeekDay(date) in this.dayOfWeek) {
+      return [
+        this._checkTimeInSkippedRange(beforeJumpingPoint, afterJumpingPoint),
+        afterJumpingPoint
+      ];
+    }
+    return [false, afterJumpingPoint];
+  }
+  _checkTimeInSkippedRange(beforeJumpingPoint, afterJumpingPoint) {
+    const startingMinute = (beforeJumpingPoint.minute + 1) % 60;
+    const startingHour = (beforeJumpingPoint.hour + (startingMinute === 0 ? 1 : 0)) % 24;
+    const hourRangeSize = afterJumpingPoint.hour - startingHour + 1;
+    const isHourJump = startingMinute === 0 && afterJumpingPoint.minute === 0;
+    if (hourRangeSize === 2 && isHourJump) {
+      return startingHour in this.hour;
+    } else if (hourRangeSize === 1) {
+      return startingHour in this.hour && this._checkTimeInSkippedRangeSingleHour(startingMinute, afterJumpingPoint.minute);
+    } else {
+      return this._checkTimeInSkippedRangeMultiHour(startingHour, startingMinute, afterJumpingPoint.hour, afterJumpingPoint.minute);
+    }
+  }
+  _checkTimeInSkippedRangeSingleHour(startMinute, endMinute) {
+    for (let minute = startMinute;minute < endMinute; ++minute) {
+      if (minute in this.minute)
+        return true;
+    }
+    return endMinute in this.minute && 0 in this.second;
+  }
+  _checkTimeInSkippedRangeMultiHour(startHour, startMinute, endHour, endMinute) {
+    if (startHour >= endHour) {
+      throw new CronError(`ERROR: This DST checking related function assumes the forward jump starting hour (${startHour}) is less than the end hour (${endHour})`);
+    }
+    const firstHourMinuteRange = Array.from({ length: 60 - startMinute }, (_, k) => startMinute + k);
+    const lastHourMinuteRange = Array.from({ length: endMinute }, (_, k) => k);
+    const middleHourMinuteRange = Array.from({ length: 60 }, (_, k) => k);
+    const selectRange = (forHour) => {
+      if (forHour === startHour)
+        return firstHourMinuteRange;
+      else if (forHour === endHour)
+        return lastHourMinuteRange;
+      else
+        return middleHourMinuteRange;
+    };
+    for (let hour = startHour;hour <= endHour; ++hour) {
+      if (!(hour in this.hour))
+        continue;
+      const usingRange = selectRange(hour);
+      for (const minute of usingRange) {
+        if (minute in this.minute)
+          return true;
+      }
+    }
+    return endHour in this.hour && endMinute in this.minute && 0 in this.second;
+  }
+  _forwardDSTJump(expectedHour, expectedMinute, actualDate) {
+    const actualHour = actualDate.hour;
+    const actualMinute = actualDate.minute;
+    const didHoursJumped = expectedHour % 24 < actualHour;
+    const didMinutesJumped = expectedMinute % 60 < actualMinute;
+    return didHoursJumped || didMinutesJumped;
+  }
+  _wcOrAll(unit) {
+    if (this._hasAll(unit))
+      return "*";
+    const all = [];
+    for (const time in this[unit])
+      all.push(time);
+    return all.join(",");
+  }
+  _hasAll(unit) {
+    const constraints = CONSTRAINTS[unit];
+    const low = constraints[0];
+    const high = unit === TIME_UNITS_MAP.DAY_OF_WEEK ? constraints[1] - 1 : constraints[1];
+    for (let i = low, n = high;i < n; i++) {
+      if (!(i in this[unit]))
+        return false;
+    }
+    return true;
+  }
+  _parse(source) {
+    source = source.toLowerCase();
+    if (Object.keys(PRESETS).includes(source))
+      source = PRESETS[source];
+    source = source.replace(/[a-z]{1,3}/gi, (alias) => {
+      if (Object.keys(ALIASES).includes(alias))
+        return ALIASES[alias].toString();
+      throw new CronError(`Unknown alias: ${alias}`);
+    });
+    const units = source.trim().split(/\s+/);
+    if (units.length < TIME_UNITS_LEN - 1)
+      throw new CronError("Too few fields");
+    if (units.length > TIME_UNITS_LEN)
+      throw new CronError("Too many fields");
+    const unitsLen = units.length;
+    for (const unit of TIME_UNITS) {
+      const i = TIME_UNITS.indexOf(unit);
+      const cur = units[i - (TIME_UNITS_LEN - unitsLen)] ?? PARSE_DEFAULTS[unit];
+      this._parseField(cur, unit);
+    }
+  }
+  _parseField(value, unit) {
+    const typeObj = this[unit];
+    let pointer;
+    const constraints = CONSTRAINTS[unit];
+    const low = constraints[0];
+    const high = constraints[1];
+    const fields = value.split(",");
+    fields.forEach((field) => {
+      const wildcardIndex = field.indexOf("*");
+      if (wildcardIndex !== -1 && wildcardIndex !== 0) {
+        throw new CronError(`Field (${field}) has an invalid wildcard expression`);
+      }
+    });
+    value = value.replace(RE_WILDCARDS, `${low}-${high}`);
+    const allRanges = value.split(",");
+    for (const range of allRanges) {
+      const match = [...range.matchAll(RE_RANGE)][0];
+      if (match?.[1] !== undefined) {
+        const [, mLower, mUpper, mStep] = match;
+        let lower = Number.parseInt(mLower, 10);
+        let upper = mUpper !== undefined ? Number.parseInt(mUpper, 10) : undefined;
+        const wasStepDefined = mStep !== undefined;
+        const step = Number.parseInt(mStep ?? "1", 10);
+        if (step === 0)
+          throw new CronError(`Field (${unit}) has a step of zero`);
+        if (upper !== undefined && lower > upper)
+          throw new CronError(`Field (${unit}) has an invalid range`);
+        const isOutOfRange = lower < low || upper !== undefined && upper > high || upper === undefined && lower > high;
+        if (isOutOfRange)
+          throw new CronError(`Field value (${value}) is out of range`);
+        lower = Math.min(Math.max(low, ~~Math.abs(lower)), high);
+        if (upper !== undefined) {
+          upper = Math.min(high, ~~Math.abs(upper));
+        } else {
+          upper = wasStepDefined ? high : lower;
+        }
+        pointer = lower;
+        do {
+          typeObj[pointer] = true;
+          pointer += step;
+        } while (pointer <= upper);
+        if (unit === "dayOfWeek") {
+          if (!typeObj[0] && !!typeObj[7])
+            typeObj[0] = typeObj[7];
+          delete typeObj[7];
+        }
+      } else {
+        throw new CronError(`Field (${unit}) cannot be parsed`);
+      }
+    }
+  }
+}
+
+// src/schedule.ts
+function sendAt(cronTime) {
+  return new CronTime(cronTime).sendAt();
+}
+function timeout(cronTime) {
+  return new CronTime(cronTime).getTimeout();
+}
+
+class Schedule {
+  cronPattern = "";
+  timezone = "America/Los_Angeles";
+  task;
+  cmd;
+  constructor(task) {
+    this.task = task;
   }
   everySecond() {
+    this.cronPattern = "* * * * * *";
+    return this;
+  }
+  everyMinute() {
+    this.cronPattern = "0 * * * * *";
     return this;
   }
   everyFiveMinutes() {
+    this.cronPattern = "*/5 * * * *";
     return this;
   }
   everyTenMinutes() {
+    this.cronPattern = "*/10 * * * *";
     return this;
   }
   everyThirtyMinutes() {
+    this.cronPattern = "*/30 * * * *";
     return this;
   }
   hourly() {
+    this.cronPattern = "0 0 * * * *";
     return this;
   }
   daily() {
-    return this;
-  }
-  twiceDaily(_hour1, _hour2) {
+    this.cronPattern = "0 0 0 * * *";
     return this;
   }
   weekly() {
+    this.cronPattern = "0 0 0 * * 0";
     return this;
   }
   monthly() {
-    return this;
-  }
-  quarterly() {
+    this.cronPattern = "0 0 0 1 * *";
     return this;
   }
   yearly() {
+    this.cronPattern = "0 0 0 1 1 *";
     return this;
   }
-  weekdays() {
+  onDays(days) {
+    const dayPattern = days.join(",");
+    this.cronPattern = `0 0 0 * * ${dayPattern}`;
     return this;
   }
-  weekends() {
+  at(time2) {
+    const [hour, minute] = time2.split(":").map(Number);
+    this.cronPattern = `${minute} ${hour} * * *`;
     return this;
   }
-  mondays() {
+  setTimeZone(timezone) {
+    this.timezone = timezone;
     return this;
   }
-  tuesdays() {
-    return this;
+  start() {
+    new CronJob(this.cronPattern, this.task, null, true, this.timezone);
+    log.info(`Scheduled task with pattern: ${this.cronPattern} in timezone: ${this.timezone}`);
   }
-  wednesdays() {
+  static command(cmd) {
+    this.cmd = cmd;
     return this;
   }
-  thursdays() {
-    return this;
+}
+
+// src/job.ts
+import {spawn} from "child_process";
+class CronJob2 {
+  cronTime;
+  running = false;
+  unrefTimeout = false;
+  lastExecution = null;
+  runOnce = false;
+  context;
+  onComplete;
+  _timeout;
+  _callbacks = [];
+  _errorHandler;
+  constructor(cronTime, onTick, onComplete, start, timeZone, context, runOnInit, utcOffset, unrefTimeout, errorHandler) {
+    this._errorHandler = errorHandler;
+    this.context = context ?? this;
+    const { timeZone: tz, utcOffset: uo } = getTimeZoneAndOffset(timeZone, utcOffset);
+    this.cronTime = new CronTime(cronTime, tz, uo);
+    if (unrefTimeout != null)
+      this.unrefTimeout = unrefTimeout;
+    if (onComplete != null) {
+      this.onComplete = this._fnWrap(onComplete);
+    }
+    if (this.cronTime.realDate)
+      this.runOnce = true;
+    this.addCallback(this._fnWrap(onTick));
+    if (runOnInit) {
+      this.lastExecution = new Date;
+      this.fireOnTick();
+    }
+    if (start)
+      this.start();
   }
-  fridays() {
-    return this;
+  static from(params) {
+    if (params.timeZone != null && params.utcOffset != null)
+      throw new ExclusiveParametersError("timeZone", "utcOffset");
+    if (params.timeZone != null) {
+      return new CronJob2(params.cronTime, params.onTick, params.onComplete, params.start, params.timeZone, params.context, params.runOnInit, params.utcOffset, params.unrefTimeout);
+    } else if (params.utcOffset != null) {
+      return new CronJob2(params.cronTime, params.onTick, params.onComplete, params.start, null, params.context, params.runOnInit, params.utcOffset, params.unrefTimeout);
+    } else {
+      return new CronJob2(params.cronTime, params.onTick, params.onComplete, params.start, params.timeZone, params.context, params.runOnInit, params.utcOffset, params.unrefTimeout);
+    }
   }
-  saturdays() {
-    return this;
+  _fnWrap(cmd) {
+    switch (typeof cmd) {
+      case "function": {
+        return cmd;
+      }
+      case "string": {
+        const [command, ...args] = cmd.split(" ");
+        return spawn.bind(undefined, command ?? cmd, args, {});
+      }
+      case "object": {
+        return spawn.bind(undefined, cmd.command, cmd.args ?? [], cmd.options ?? {});
+      }
+    }
   }
-  sundays() {
-    return this;
+  addCallback(callback2) {
+    if (typeof callback2 === "function")
+      this._callbacks.push(callback2);
   }
-  between(startTime, endTime) {
-    this.startTime = startTime;
-    this.endTime = endTime;
-    return this;
+  setTime(time3) {
+    if (!(time3 instanceof CronTime))
+      throw new CronError("time must be an instance of CronTime.");
+    const wasRunning = this.running;
+    this.stop();
+    this.cronTime = time3;
+    if (time3.realDate)
+      this.runOnce = true;
+    if (wasRunning)
+      this.start();
   }
-  timezone(timezone) {
-    this.timezoneName = timezone;
-    return this;
+  nextDate() {
+    return this.cronTime.sendAt();
   }
-  when(callback) {
-    this.whenCallback = callback;
-    return this;
+  fireOnTick() {
+    try {
+      callback.call(this.context, this.onComplete);
+    } catch (error) {
+      if (this._errorHandler && error instanceof Error) {
+        this._errorHandler(error);
+      } else {
+        console.error("An error occurred in the cron job callback:", error);
+      }
+    }
   }
-  at(time) {
-    this.time = time;
-    return this;
+  nextDates(i) {
+    return this.cronTime.sendAt(i ?? 0);
+  }
+  start() {
+    if (this.running)
+      return;
+    const MAXDELAY = 2147483647;
+    let timeout2 = this.cronTime.getTimeout();
+    let remaining = 0;
+    let startTime;
+    const setCronTimeout = (t) => {
+      startTime = Date.now();
+      this._timeout = setTimeout(callbackWrapper, t);
+      if (this.unrefTimeout && typeof this._timeout.unref === "function")
+        this._timeout.unref();
+    };
+    const callbackWrapper = () => {
+      const diff = startTime + timeout2 - Date.now();
+      if (diff > 0) {
+        let newTimeout = this.cronTime.getTimeout();
+        if (newTimeout > diff)
+          newTimeout = diff;
+        remaining += newTimeout;
+      }
+      if (remaining) {
+        if (remaining > MAXDELAY) {
+          remaining -= MAXDELAY;
+          timeout2 = MAXDELAY;
+        } else {
+          timeout2 = remaining;
+          remaining = 0;
+        }
+        setCronTimeout(timeout2);
+      } else {
+        this.lastExecution = new Date;
+        this.running = false;
+        if (!this.runOnce)
+          this.start();
+        this.fireOnTick();
+      }
+    };
+    if (timeout2 >= 0) {
+      this.running = true;
+      if (timeout2 > MAXDELAY) {
+        remaining = timeout2 - MAXDELAY;
+        timeout2 = MAXDELAY;
+      }
+      setCronTimeout(timeout2);
+    } else {
+      this.stop();
+    }
+  }
+  lastDate() {
+    return this.lastExecution;
+  }
+  stop() {
+    if (this._timeout)
+      clearTimeout(this._timeout);
+    this.running = false;
+    if (typeof this.onComplete === "function")
+      this.onComplete.call(this.context);
   }
 }
+
+// src/index.ts
+var src_default = Schedule;
 export {
-  useScheduler,
-  run,
-  ScheduleImpl
+  timeout,
+  sendAt,
+  src_default as default,
+  Schedule,
+  CronTime,
+  CronJob2 as CronJob
 };