alepha 0.15.0 → 0.15.2

package/dist/scheduler/index.d.ts

@@ -1,9 +1,8 @@
-import * as alepha4 from "alepha";
+import * as alepha1 from "alepha";
 import { Alepha, Async, KIND, Primitive, Static } from "alepha";
 import * as alepha_lock0 from "alepha/lock";
 import { DateTime, DateTimeProvider, DurationLike } from "alepha/datetime";
 import * as alepha_logger0 from "alepha/logger";
-import { Cron } from "cron-schedule";
 import * as dayjs0 from "dayjs";
 
 //#region ../../src/scheduler/constants/CRON.d.ts
@@ -16,6 +15,89 @@ declare const CRON: {
   EVERY_DAY_AT_MIDNIGHT: string;
 };
 //#endregion
+//#region ../../../../node_modules/cron-schedule/dist/cron.d.ts
+/**
+ * An object with contains for each element of a date, which values are allowed.
+ * Everything starting at 0, except for days.
+ */
+interface ICronDefinition {
+  readonly seconds: Set<number>;
+  readonly minutes: Set<number>;
+  readonly hours: Set<number>;
+  readonly days: Set<number>;
+  readonly months: Set<number>;
+  readonly weekdays: Set<number>;
+}
+declare class Cron {
+  readonly seconds: ReadonlyArray<number>;
+  readonly minutes: ReadonlyArray<number>;
+  readonly hours: ReadonlyArray<number>;
+  readonly days: ReadonlyArray<number>;
+  readonly months: ReadonlyArray<number>;
+  readonly weekdays: ReadonlyArray<number>;
+  readonly reversed: {
+    seconds: ReadonlyArray<number>;
+    minutes: ReadonlyArray<number>;
+    hours: ReadonlyArray<number>;
+    days: ReadonlyArray<number>;
+    months: ReadonlyArray<number>;
+    weekdays: ReadonlyArray<number>;
+  };
+  constructor({
+    seconds,
+    minutes,
+    hours,
+    days,
+    months,
+    weekdays
+  }: ICronDefinition);
+  /**
+   * Find the next or previous hour, starting from the given start hour that matches the hour constraint.
+   * startHour itself might also be allowed.
+   */
+  private findAllowedHour;
+  /**
+   * Find the next or previous minute, starting from the given start minute that matches the minute constraint.
+   * startMinute itself might also be allowed.
+   */
+  private findAllowedMinute;
+  /**
+   * Find the next or previous second, starting from the given start second that matches the second constraint.
+   * startSecond itself IS NOT allowed.
+   */
+  private findAllowedSecond;
+  /**
+   * Find the next or previous time, starting from the given start time that matches the hour, minute
+   * and second constraints. startTime itself might also be allowed.
+   */
+  private findAllowedTime;
+  /**
+   * Find the next or previous day in the given month, starting from the given startDay
+   * that matches either the day or the weekday constraint. startDay itself might also be allowed.
+   */
+  private findAllowedDayInMonth;
+  /** Gets the next date starting from the given start date or now. */
+  getNextDate(startDate?: Date): Date;
+  /** Gets the specified amount of future dates starting from the given start date or now. */
+  getNextDates(amount: number, startDate?: Date): Date[];
+  /**
+   * Get an ES6 compatible iterator which iterates over the next dates starting from startDate or now.
+   * The iterator runs until the optional endDate is reached or forever.
+   */
+  getNextDatesIterator(startDate?: Date, endDate?: Date): Generator<Date, undefined, undefined>;
+  /** Gets the previous date starting from the given start date or now. */
+  getPrevDate(startDate?: Date): Date;
+  /** Gets the specified amount of previous dates starting from the given start date or now. */
+  getPrevDates(amount: number, startDate?: Date): Date[];
+  /**
+   * Get an ES6 compatible iterator which iterates over the previous dates starting from startDate or now.
+   * The iterator runs until the optional endDate is reached or forever.
+   */
+  getPrevDatesIterator(startDate?: Date, endDate?: Date): Generator<Date, undefined, undefined>;
+  /** Returns true when there is a cron date at the given date. */
+  matchDate(date: Date): boolean;
+}
+//#endregion
 //#region ../../src/scheduler/providers/CronProvider.d.ts
 declare class CronProvider {
   protected readonly dt: DateTimeProvider;
@@ -23,15 +105,15 @@ declare class CronProvider {
   protected readonly log: alepha_logger0.Logger;
   protected readonly cronJobs: Array<CronJob>;
   getCronJobs(): Array<CronJob>;
-  protected readonly start: alepha4.HookPrimitive<"start">;
-  protected readonly stop: alepha4.HookPrimitive<"stop">;
+  protected readonly start: alepha1.HookPrimitive<"start">;
+  protected readonly stop: alepha1.HookPrimitive<"stop">;
   protected boot(name: string | CronJob): void;
   abort(name: string | CronJob): void;
   /**
-       * Registers a cron job.
-       *
-       * It's automatically done when using the `$scheduler` primitive but can also be used manually.
-       */
+   * Registers a cron job.
+   *
+   * It's automatically done when using the `$scheduler` primitive but can also be used manually.
+   */
   createCronJob(name: string, expression: string, handler: (context: {
     now: DateTime;
   }) => Promise<void>, start?: boolean): void;
@@ -60,35 +142,35 @@ declare const $scheduler: {
 };
 type SchedulerPrimitiveOptions = {
   /**
-       * Function to run on schedule.
-       */
+   * Function to run on schedule.
+   */
   handler: (args: SchedulerHandlerArguments) => Async<void>;
   /**
-       * Name of the scheduler. Defaults to the function name.
-       */
+   * Name of the scheduler. Defaults to the function name.
+   */
   name?: string;
   /**
-       * Optional description of the scheduler.
-       */
+   * Optional description of the scheduler.
+   */
   description?: string;
   /**
-       * Cron expression or interval to run the scheduler.
-       */
+   * Cron expression or interval to run the scheduler.
+   */
   cron?: string;
   /**
-       * Cron expression or interval to run the scheduler.
-       */
+   * Cron expression or interval to run the scheduler.
+   */
   interval?: DurationLike;
   /**
-       * If true, the scheduler will be locked and only one instance will run at a time.
-       * You probably need to import {@link AlephaLockRedis} for distributed locking.
-       *
-       * @default true
-       */
+   * If true, the scheduler will be locked and only one instance will run at a time.
+   * You probably need to import {@link AlephaLockRedis} for distributed locking.
+   *
+   * @default true
+   */
   lock?: boolean;
 };
-declare const envSchema: alepha4.TObject<{
-  SCHEDULER_PREFIX: alepha4.TOptional<alepha4.TString>;
+declare const envSchema: alepha1.TObject<{
+  SCHEDULER_PREFIX: alepha1.TOptional<alepha1.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
@@ -134,12 +216,21 @@ declare module "alepha" {
   }
 }
 /**
- * Generic interface for scheduling tasks.
+ * | type | quality | stability |
+ * |------|---------|-----------|
+ * | backend | rare | stable |
+ *
+ * Cron and interval-based task execution.
+ *
+ * **Features:**
+ * - Scheduled tasks with cron expressions (e.g., `0 0 * * *`)
+ * - Interval-based scheduling
+ * - Distributed locking to prevent duplicate execution
+ * - Lifecycle hooks: `begin`, `success`, `error`, `end`
  *
- * @see {@link $scheduler}
  * @module alepha.scheduler
  */
-declare const AlephaScheduler: alepha4.Service<alepha4.Module>;
+declare const AlephaScheduler: alepha1.Service<alepha1.Module>;
 //#endregion
 export { $scheduler, AlephaScheduler, CRON, CronJob, CronProvider, SchedulerHandlerArguments, SchedulerPrimitive, SchedulerPrimitiveOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/scheduler/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/scheduler/constants/CRON.ts","../../src/scheduler/providers/CronProvider.ts","../../src/scheduler/primitives/$scheduler.ts","../../src/scheduler/index.ts"],"mappings":";;;;;;;;;cAAa,IAAA;EAAA,YAAA;EAAA,eAAA;EAAA,gBAAA;EAAA,gBAAA;EAAA,UAAA;EAAA,qBAAA;AAAA;;;cCKA,YAAA;EAAA,mBAAA,EAAA,EACU,gBAAA;EAAA,mBAAA,MAAA,EACI,MAAA;EAAA,mBAAA,GAAA,EAAA,cAAA,CACH,MAAA;EAAA,mBAAA,QAAA,EACO,KAAA,CAAM,OAAA;EAAA,YAAA,GAEb,KAAA,CAAM,OAAA;EAAA,mBAAA,KAAA,EAAD,OAAA,CAIH,aAAA;EAAA,mBAAA,IAAA,EAAA,OAAA,CAeD,aAAA;EAAA,UAAA,KAAA,IAAA,WASO,OAAA;EAAA,MAAA,IAAA,WAmBF,OAAA;EAAA;;;;;EAAA,cAAA,IAAA,UAAA,UAAA,UAAA,OAAA,GAAA,OAAA;IAAA,GAAA,EAuBA,QAAA;EAAA,MAAe,OAAA,QAAA,KAAA;EAAA,UAAA,IAAA,IAAA,EAmBvB,OAAA,EAAA,GAAA,GAAO,MAAA,CAAK,KAAA;AAAA;AAAA,UA6CjB,OAAA;EAAA,IAAA;EAAA,UAAA;EAAA,OAAA,GAAA,OAAA;IAAA,GAAA,EAGW,QAAA;EAAA,MAAe,OAAA;EAAA,IAAA,EACnC,IAAA;EAAA,IAAA;EAAA,OAAA;EAAA,OAAA,IAAA,KAAA,EAGY,KAAA;EAAA,KAAA,EACX,eAAA;AAAA;;;;AClIT;;cAAa,UAAA;EAAA,CAAA,OAAA,EACF,yBAAA,GACR,kBAAA;EAAA;;KAMS,yBAAA;EAAA;;;EAAA,OAAA,GAAA,IAAA,EAIM,yBAAA,KAA8B,KAAA;EAAA;;;EAAA,IAAA;EAAA;;;EAAA,WAAA;EAAA;;;EAAA,IAAA;EAAA;;;EAAA,QAAA,GAoBnC,YAAA;EAAA;;AASX;;;;EATW,IAAA;AAAA;AAAA,cAaP,SAAA,UAAS,OAAA;EAAA,gBAAA,oBAMb,OAAA,CAAA,OAAA;AAAA;AAAA;EAAA,UAAA,GAAA,SAGsB,OAAA,CAAQ,MAAA,QAAc,SAAA;AAAA;AAAA,cAGjC,kBAAA,SAA2B,SAAA,CAAU,yBAAA;EAAA,mBAAA,GAAA,EAAyB,cAAA,CACnD,MAAA;EAAA,mBAAA,GAAA;IAAA,gBAAA;EAAA;EAAA,mBAAA,MAAA,EAEG,MAAA;EAAA,mBAAA,gBAAA,EACU,gBAAA;EAAA,mBAAA,YAAA,EACJ,YAAA;EAAA,IAAA,KAAA;EAAA,UAAA,OAAA;EAAA,QAAA,GAuBP,OAAA;EAAA,UAAA,aAAA,EA0EyB,YAAA,CAP1B,aAAA,EAAA,IAAA,EAOC,yBAAA,KAAyB,OAAA;AAAA;AAAA,UAUlC,yBAAA;EAAA,GAAA,EACV,QAAA;AAAA;;;;;;;WC/KI,QAAA;MAAA,OAAA;IAAA;IAAA;MAAA,IAAA;MAAA,OAAA;IAAA;IAAA;MAAA,IAAA;MAAA,KAAA,EAQE,KAAA;MAAA,OAAA;IAAA;IAAA;MAAA,IAAA;MAAA,OAAA;IAAA;EAAA;AAAA;AAAA;;;AAgBb;;;AAhBa,cAgBA,eAAA,EAAe,OAAA,CAAA,OAAA,CAI1B,OAAA,CAJ0B,MAAA"}
+{"version":3,"file":"index.d.ts","names":["ICronDefinition","Set","seconds","minutes","hours","days","months","weekdays","Cron","ReadonlyArray","Date","Generator","reversed","constructor","findAllowedHour","findAllowedMinute","findAllowedSecond","findAllowedTime","findAllowedDayInMonth","getNextDate","startDate","getNextDates","amount","getNextDatesIterator","endDate","getPrevDate","getPrevDates","getPrevDatesIterator","matchDate","date"],"sources":["../../src/scheduler/constants/CRON.ts","../../../../node_modules/cron-schedule/dist/cron.d.ts","../../src/scheduler/providers/CronProvider.ts","../../src/scheduler/primitives/$scheduler.ts","../../src/scheduler/index.ts"],"x_google_ignoreList":[1],"mappings":"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"}

package/dist/scheduler/index.js

@@ -2,8 +2,400 @@ import { $env, $hook, $inject, $module, Alepha, KIND, Primitive, createPrimitive
 import { $lock, AlephaLock } from "alepha/lock";
 import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
-import { parseCronExpression } from "cron-schedule";
 
+//#region ../../../../node_modules/cron-schedule/dist/utils.js
+function extractDateElements(date) {
+	return {
+		second: date.getSeconds(),
+		minute: date.getMinutes(),
+		hour: date.getHours(),
+		day: date.getDate(),
+		month: date.getMonth(),
+		weekday: date.getDay(),
+		year: date.getFullYear()
+	};
+}
+function getDaysInMonth(year, month) {
+	return new Date(year, month + 1, 0).getDate();
+}
+function getDaysBetweenWeekdays(weekday1, weekday2) {
+	if (weekday1 <= weekday2) return weekday2 - weekday1;
+	return 6 - weekday1 + weekday2 + 1;
+}
+
+//#endregion
+//#region ../../../../node_modules/cron-schedule/dist/cron.js
+var Cron = class {
+	constructor({ seconds, minutes, hours, days, months, weekdays }) {
+		if (!seconds || seconds.size === 0) throw new Error("There must be at least one allowed second.");
+		if (!minutes || minutes.size === 0) throw new Error("There must be at least one allowed minute.");
+		if (!hours || hours.size === 0) throw new Error("There must be at least one allowed hour.");
+		if (!months || months.size === 0) throw new Error("There must be at least one allowed month.");
+		if ((!weekdays || weekdays.size === 0) && (!days || days.size === 0)) throw new Error("There must be at least one allowed day or weekday.");
+		this.seconds = Array.from(seconds).sort((a, b) => a - b);
+		this.minutes = Array.from(minutes).sort((a, b) => a - b);
+		this.hours = Array.from(hours).sort((a, b) => a - b);
+		this.days = Array.from(days).sort((a, b) => a - b);
+		this.months = Array.from(months).sort((a, b) => a - b);
+		this.weekdays = Array.from(weekdays).sort((a, b) => a - b);
+		const validateData = (name, data, constraint) => {
+			if (data.some((x) => typeof x !== "number" || x % 1 !== 0 || x < constraint.min || x > constraint.max)) throw new Error(`${name} must only consist of integers which are within the range of ${constraint.min} and ${constraint.max}`);
+		};
+		validateData("seconds", this.seconds, {
+			min: 0,
+			max: 59
+		});
+		validateData("minutes", this.minutes, {
+			min: 0,
+			max: 59
+		});
+		validateData("hours", this.hours, {
+			min: 0,
+			max: 23
+		});
+		validateData("days", this.days, {
+			min: 1,
+			max: 31
+		});
+		validateData("months", this.months, {
+			min: 0,
+			max: 11
+		});
+		validateData("weekdays", this.weekdays, {
+			min: 0,
+			max: 6
+		});
+		this.reversed = {
+			seconds: this.seconds.map((x) => x).reverse(),
+			minutes: this.minutes.map((x) => x).reverse(),
+			hours: this.hours.map((x) => x).reverse(),
+			days: this.days.map((x) => x).reverse(),
+			months: this.months.map((x) => x).reverse(),
+			weekdays: this.weekdays.map((x) => x).reverse()
+		};
+	}
+	/**
+	* Find the next or previous hour, starting from the given start hour that matches the hour constraint.
+	* startHour itself might also be allowed.
+	*/
+	findAllowedHour(dir, startHour) {
+		return dir === "next" ? this.hours.find((x) => x >= startHour) : this.reversed.hours.find((x) => x <= startHour);
+	}
+	/**
+	* Find the next or previous minute, starting from the given start minute that matches the minute constraint.
+	* startMinute itself might also be allowed.
+	*/
+	findAllowedMinute(dir, startMinute) {
+		return dir === "next" ? this.minutes.find((x) => x >= startMinute) : this.reversed.minutes.find((x) => x <= startMinute);
+	}
+	/**
+	* Find the next or previous second, starting from the given start second that matches the second constraint.
+	* startSecond itself IS NOT allowed.
+	*/
+	findAllowedSecond(dir, startSecond) {
+		return dir === "next" ? this.seconds.find((x) => x > startSecond) : this.reversed.seconds.find((x) => x < startSecond);
+	}
+	/**
+	* Find the next or previous time, starting from the given start time that matches the hour, minute
+	* and second constraints. startTime itself might also be allowed.
+	*/
+	findAllowedTime(dir, startTime) {
+		let hour = this.findAllowedHour(dir, startTime.hour);
+		if (hour !== void 0) if (hour === startTime.hour) {
+			let minute = this.findAllowedMinute(dir, startTime.minute);
+			if (minute !== void 0) if (minute === startTime.minute) {
+				const second = this.findAllowedSecond(dir, startTime.second);
+				if (second !== void 0) return {
+					hour,
+					minute,
+					second
+				};
+				minute = this.findAllowedMinute(dir, dir === "next" ? startTime.minute + 1 : startTime.minute - 1);
+				if (minute !== void 0) return {
+					hour,
+					minute,
+					second: dir === "next" ? this.seconds[0] : this.reversed.seconds[0]
+				};
+			} else return {
+				hour,
+				minute,
+				second: dir === "next" ? this.seconds[0] : this.reversed.seconds[0]
+			};
+			hour = this.findAllowedHour(dir, dir === "next" ? startTime.hour + 1 : startTime.hour - 1);
+			if (hour !== void 0) return {
+				hour,
+				minute: dir === "next" ? this.minutes[0] : this.reversed.minutes[0],
+				second: dir === "next" ? this.seconds[0] : this.reversed.seconds[0]
+			};
+		} else return {
+			hour,
+			minute: dir === "next" ? this.minutes[0] : this.reversed.minutes[0],
+			second: dir === "next" ? this.seconds[0] : this.reversed.seconds[0]
+		};
+	}
+	/**
+	* Find the next or previous day in the given month, starting from the given startDay
+	* that matches either the day or the weekday constraint. startDay itself might also be allowed.
+	*/
+	findAllowedDayInMonth(dir, year, month, startDay) {
+		var _a, _b;
+		if (startDay < 1) throw new Error("startDay must not be smaller than 1.");
+		const daysInMonth = getDaysInMonth(year, month);
+		const daysRestricted = this.days.length !== 31;
+		const weekdaysRestricted = this.weekdays.length !== 7;
+		if (!daysRestricted && !weekdaysRestricted) {
+			if (startDay > daysInMonth) return dir === "next" ? void 0 : daysInMonth;
+			return startDay;
+		}
+		let allowedDayByDays;
+		if (daysRestricted) {
+			allowedDayByDays = dir === "next" ? this.days.find((x) => x >= startDay) : this.reversed.days.find((x) => x <= startDay);
+			if (allowedDayByDays !== void 0 && allowedDayByDays > daysInMonth) allowedDayByDays = void 0;
+		}
+		let allowedDayByWeekdays;
+		if (weekdaysRestricted) {
+			const startWeekday = new Date(year, month, startDay).getDay();
+			const nearestAllowedWeekday = dir === "next" ? (_a = this.weekdays.find((x) => x >= startWeekday)) !== null && _a !== void 0 ? _a : this.weekdays[0] : (_b = this.reversed.weekdays.find((x) => x <= startWeekday)) !== null && _b !== void 0 ? _b : this.reversed.weekdays[0];
+			if (nearestAllowedWeekday !== void 0) {
+				const daysBetweenWeekdays = dir === "next" ? getDaysBetweenWeekdays(startWeekday, nearestAllowedWeekday) : getDaysBetweenWeekdays(nearestAllowedWeekday, startWeekday);
+				allowedDayByWeekdays = dir === "next" ? startDay + daysBetweenWeekdays : startDay - daysBetweenWeekdays;
+				if (allowedDayByWeekdays > daysInMonth || allowedDayByWeekdays < 1) allowedDayByWeekdays = void 0;
+			}
+		}
+		if (allowedDayByDays !== void 0 && allowedDayByWeekdays !== void 0) return dir === "next" ? Math.min(allowedDayByDays, allowedDayByWeekdays) : Math.max(allowedDayByDays, allowedDayByWeekdays);
+		if (allowedDayByDays !== void 0) return allowedDayByDays;
+		if (allowedDayByWeekdays !== void 0) return allowedDayByWeekdays;
+	}
+	/** Gets the next date starting from the given start date or now. */
+	getNextDate(startDate = /* @__PURE__ */ new Date()) {
+		const startDateElements = extractDateElements(startDate);
+		let minYear = startDateElements.year;
+		let startIndexMonth = this.months.findIndex((x) => x >= startDateElements.month);
+		if (startIndexMonth === -1) {
+			startIndexMonth = 0;
+			minYear++;
+		}
+		const maxIterations = this.months.length * 5;
+		for (let i = 0; i < maxIterations; i++) {
+			const year = minYear + Math.floor((startIndexMonth + i) / this.months.length);
+			const month = this.months[(startIndexMonth + i) % this.months.length];
+			const isStartMonth = year === startDateElements.year && month === startDateElements.month;
+			let day = this.findAllowedDayInMonth("next", year, month, isStartMonth ? startDateElements.day : 1);
+			let isStartDay = isStartMonth && day === startDateElements.day;
+			if (day !== void 0 && isStartDay) {
+				const nextTime = this.findAllowedTime("next", startDateElements);
+				if (nextTime !== void 0) return new Date(year, month, day, nextTime.hour, nextTime.minute, nextTime.second);
+				day = this.findAllowedDayInMonth("next", year, month, day + 1);
+				isStartDay = false;
+			}
+			if (day !== void 0 && !isStartDay) return new Date(year, month, day, this.hours[0], this.minutes[0], this.seconds[0]);
+		}
+		throw new Error("No valid next date was found.");
+	}
+	/** Gets the specified amount of future dates starting from the given start date or now. */
+	getNextDates(amount, startDate) {
+		const dates = [];
+		let nextDate;
+		for (let i = 0; i < amount; i++) {
+			nextDate = this.getNextDate(nextDate !== null && nextDate !== void 0 ? nextDate : startDate);
+			dates.push(nextDate);
+		}
+		return dates;
+	}
+	/**
+	* Get an ES6 compatible iterator which iterates over the next dates starting from startDate or now.
+	* The iterator runs until the optional endDate is reached or forever.
+	*/
+	*getNextDatesIterator(startDate, endDate) {
+		let nextDate;
+		while (true) {
+			nextDate = this.getNextDate(nextDate !== null && nextDate !== void 0 ? nextDate : startDate);
+			if (endDate && endDate.getTime() < nextDate.getTime()) return;
+			yield nextDate;
+		}
+	}
+	/** Gets the previous date starting from the given start date or now. */
+	getPrevDate(startDate = /* @__PURE__ */ new Date()) {
+		const startDateElements = extractDateElements(startDate);
+		let maxYear = startDateElements.year;
+		let startIndexMonth = this.reversed.months.findIndex((x) => x <= startDateElements.month);
+		if (startIndexMonth === -1) {
+			startIndexMonth = 0;
+			maxYear--;
+		}
+		const maxIterations = this.reversed.months.length * 5;
+		for (let i = 0; i < maxIterations; i++) {
+			const year = maxYear - Math.floor((startIndexMonth + i) / this.reversed.months.length);
+			const month = this.reversed.months[(startIndexMonth + i) % this.reversed.months.length];
+			const isStartMonth = year === startDateElements.year && month === startDateElements.month;
+			let day = this.findAllowedDayInMonth("prev", year, month, isStartMonth ? startDateElements.day : getDaysInMonth(year, month));
+			let isStartDay = isStartMonth && day === startDateElements.day;
+			if (day !== void 0 && isStartDay) {
+				const prevTime = this.findAllowedTime("prev", startDateElements);
+				if (prevTime !== void 0) return new Date(year, month, day, prevTime.hour, prevTime.minute, prevTime.second);
+				if (day > 1) {
+					day = this.findAllowedDayInMonth("prev", year, month, day - 1);
+					isStartDay = false;
+				}
+			}
+			if (day !== void 0 && !isStartDay) return new Date(year, month, day, this.reversed.hours[0], this.reversed.minutes[0], this.reversed.seconds[0]);
+		}
+		throw new Error("No valid previous date was found.");
+	}
+	/** Gets the specified amount of previous dates starting from the given start date or now. */
+	getPrevDates(amount, startDate) {
+		const dates = [];
+		let prevDate;
+		for (let i = 0; i < amount; i++) {
+			prevDate = this.getPrevDate(prevDate !== null && prevDate !== void 0 ? prevDate : startDate);
+			dates.push(prevDate);
+		}
+		return dates;
+	}
+	/**
+	* Get an ES6 compatible iterator which iterates over the previous dates starting from startDate or now.
+	* The iterator runs until the optional endDate is reached or forever.
+	*/
+	*getPrevDatesIterator(startDate, endDate) {
+		let prevDate;
+		while (true) {
+			prevDate = this.getPrevDate(prevDate !== null && prevDate !== void 0 ? prevDate : startDate);
+			if (endDate && endDate.getTime() > prevDate.getTime()) return;
+			yield prevDate;
+		}
+	}
+	/** Returns true when there is a cron date at the given date. */
+	matchDate(date) {
+		const { second, minute, hour, day, month, weekday } = extractDateElements(date);
+		if (this.seconds.indexOf(second) === -1 || this.minutes.indexOf(minute) === -1 || this.hours.indexOf(hour) === -1 || this.months.indexOf(month) === -1) return false;
+		if (this.days.length !== 31 && this.weekdays.length !== 7) return this.days.indexOf(day) !== -1 || this.weekdays.indexOf(weekday) !== -1;
+		return this.days.indexOf(day) !== -1 && this.weekdays.indexOf(weekday) !== -1;
+	}
+};
+
+//#endregion
+//#region ../../../../node_modules/cron-schedule/dist/cron-parser.js
+const secondConstraint = {
+	min: 0,
+	max: 59
+};
+const minuteConstraint = {
+	min: 0,
+	max: 59
+};
+const hourConstraint = {
+	min: 0,
+	max: 23
+};
+const dayConstraint = {
+	min: 1,
+	max: 31
+};
+const monthConstraint = {
+	min: 1,
+	max: 12,
+	aliases: {
+		jan: "1",
+		feb: "2",
+		mar: "3",
+		apr: "4",
+		may: "5",
+		jun: "6",
+		jul: "7",
+		aug: "8",
+		sep: "9",
+		oct: "10",
+		nov: "11",
+		dec: "12"
+	}
+};
+const weekdayConstraint = {
+	min: 0,
+	max: 7,
+	aliases: {
+		mon: "1",
+		tue: "2",
+		wed: "3",
+		thu: "4",
+		fri: "5",
+		sat: "6",
+		sun: "7"
+	}
+};
+const timeNicknames = {
+	"@yearly": "0 0 1 1 *",
+	"@annually": "0 0 1 1 *",
+	"@monthly": "0 0 1 * *",
+	"@weekly": "0 0 * * 0",
+	"@daily": "0 0 * * *",
+	"@hourly": "0 * * * *",
+	"@minutely": "* * * * *"
+};
+function parseElement(element, constraint) {
+	const result = /* @__PURE__ */ new Set();
+	if (element === "*") {
+		for (let i = constraint.min; i <= constraint.max; i = i + 1) result.add(i);
+		return result;
+	}
+	const listElements = element.split(",");
+	if (listElements.length > 1) {
+		for (const listElement of listElements) {
+			const parsedListElement = parseElement(listElement, constraint);
+			for (const x of parsedListElement) result.add(x);
+		}
+		return result;
+	}
+	const parseSingleElement = (singleElement) => {
+		var _a, _b;
+		singleElement = (_b = (_a = constraint.aliases) === null || _a === void 0 ? void 0 : _a[singleElement.toLowerCase()]) !== null && _b !== void 0 ? _b : singleElement;
+		const parsedElement = Number.parseInt(singleElement, 10);
+		if (Number.isNaN(parsedElement)) throw new Error(`Failed to parse ${element}: ${singleElement} is NaN.`);
+		if (parsedElement < constraint.min || parsedElement > constraint.max) throw new Error(`Failed to parse ${element}: ${singleElement} is outside of constraint range of ${constraint.min} - ${constraint.max}.`);
+		return parsedElement;
+	};
+	const rangeSegments = /^(([0-9a-zA-Z]+)-([0-9a-zA-Z]+)|\*)(\/([0-9]+))?$/.exec(element);
+	if (rangeSegments === null) {
+		result.add(parseSingleElement(element));
+		return result;
+	}
+	let parsedStart = rangeSegments[1] === "*" ? constraint.min : parseSingleElement(rangeSegments[2]);
+	const parsedEnd = rangeSegments[1] === "*" ? constraint.max : parseSingleElement(rangeSegments[3]);
+	if (constraint === weekdayConstraint && parsedStart === 7 && parsedEnd !== 7) parsedStart = 0;
+	if (parsedStart > parsedEnd) throw new Error(`Failed to parse ${element}: Invalid range (start: ${parsedStart}, end: ${parsedEnd}).`);
+	const step = rangeSegments[5];
+	let parsedStep = 1;
+	if (step !== void 0) {
+		parsedStep = Number.parseInt(step, 10);
+		if (Number.isNaN(parsedStep)) throw new Error(`Failed to parse step: ${step} is NaN.`);
+		if (parsedStep < 1) throw new Error(`Failed to parse step: Expected ${step} to be greater than 0.`);
+	}
+	for (let i = parsedStart; i <= parsedEnd; i = i + parsedStep) result.add(i);
+	return result;
+}
+/** Parses a cron expression into a Cron instance. */
+function parseCronExpression(cronExpression) {
+	var _a;
+	if (typeof cronExpression !== "string") throw new TypeError("Invalid cron expression: must be of type string.");
+	cronExpression = (_a = timeNicknames[cronExpression.toLowerCase()]) !== null && _a !== void 0 ? _a : cronExpression;
+	const elements = cronExpression.split(" ").filter((elem) => elem.length > 0);
+	if (elements.length < 5 || elements.length > 6) throw new Error("Invalid cron expression: expected 5 or 6 elements.");
+	const rawSeconds = elements.length === 6 ? elements[0] : "0";
+	const rawMinutes = elements.length === 6 ? elements[1] : elements[0];
+	const rawHours = elements.length === 6 ? elements[2] : elements[1];
+	const rawDays = elements.length === 6 ? elements[3] : elements[2];
+	const rawMonths = elements.length === 6 ? elements[4] : elements[3];
+	const rawWeekdays = elements.length === 6 ? elements[5] : elements[4];
+	return new Cron({
+		seconds: parseElement(rawSeconds, secondConstraint),
+		minutes: parseElement(rawMinutes, minuteConstraint),
+		hours: parseElement(rawHours, hourConstraint),
+		days: parseElement(rawDays, dayConstraint),
+		months: new Set(Array.from(parseElement(rawMonths, monthConstraint)).map((x) => x - 1)),
+		weekdays: new Set(Array.from(parseElement(rawWeekdays, weekdayConstraint)).map((x) => x % 7))
+	});
+}
+
+//#endregion
 //#region ../../src/scheduler/providers/CronProvider.ts
 var CronProvider = class {
 	dt = $inject(DateTimeProvider);
@@ -164,9 +556,18 @@ const CRON = {
 //#endregion
 //#region ../../src/scheduler/index.ts
 /**
-* Generic interface for scheduling tasks.
+* | type | quality | stability |
+* |------|---------|-----------|
+* | backend | rare | stable |
+*
+* Cron and interval-based task execution.
+*
+* **Features:**
+* - Scheduled tasks with cron expressions (e.g., `0 0 * * *`)
+* - Interval-based scheduling
+* - Distributed locking to prevent duplicate execution
+* - Lifecycle hooks: `begin`, `success`, `error`, `end`
 *
-* @see {@link $scheduler}
 * @module alepha.scheduler
 */
 const AlephaScheduler = $module({