semola 0.5.2 → 0.5.4

package/dist/lib/cron/index.cjs

@@ -1,8 +1,427 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_lib_errors_index = require("../errors/index.cjs");
-const require_scanner = require("../../cron/scanner.cjs");
-//#region src/lib/cron/index.ts
+//#region src/lib/cron/builder/index.ts
+const CRON_FIELD_ORDER = [
+	"second",
+	"minute",
+	"hour",
+	"day",
+	"month",
+	"weekday"
+];
+var FieldWrapper = class {
+	fields = [];
+	add(expr) {
+		this.fields.push(expr);
+	}
+	read() {
+		return this.fields;
+	}
+};
+var CronListBuilder = class {
+	wrapper;
+	constructor(wrapper) {
+		this.wrapper = wrapper;
+	}
+	any() {
+		this.wrapper.add({ type: "any" });
+		return this;
+	}
+	range(options) {
+		this.wrapper.add({
+			type: "range",
+			...options
+		});
+		return this;
+	}
+	step(options) {
+		this.wrapper.add({
+			type: "step",
+			...options
+		});
+		return this;
+	}
+	number(value) {
+		this.wrapper.add({
+			type: "value",
+			value
+		});
+		return this;
+	}
+};
+function range(options) {
+	return {
+		type: "range",
+		...options
+	};
+}
+function any() {
+	return { type: "any" };
+}
+function step(options) {
+	return {
+		type: "step",
+		...options
+	};
+}
+function list(builderFn) {
+	const wrapper = new FieldWrapper();
+	builderFn(new CronListBuilder(wrapper));
+	return {
+		type: "list",
+		values: wrapper.read()
+	};
+}
+function number(value) {
+	return {
+		type: "value",
+		value
+	};
+}
+function cronJobBuilder(buildFn) {
+	const fields = {
+		second: void 0,
+		minute: void 0,
+		hour: void 0,
+		day: void 0,
+		month: void 0,
+		weekday: void 0
+	};
+	const obj = {
+		second(expr) {
+			fields.second = checkExpr(expr);
+			return obj;
+		},
+		minute(expr) {
+			fields.minute = checkExpr(expr);
+			return obj;
+		},
+		hour(expr) {
+			fields.hour = checkExpr(expr);
+			return obj;
+		},
+		day(expr) {
+			fields.day = checkExpr(expr);
+			return obj;
+		},
+		month(expr) {
+			fields.month = checkExpr(expr);
+			return obj;
+		},
+		weekday(expr) {
+			fields.weekday = checkExpr(expr);
+			return obj;
+		}
+	};
+	buildFn(obj);
+	return generate(fields);
+}
+function checkExpr(expr) {
+	if (expr.type === "list") {
+		const { values } = expr;
+		if (values.length === 0) throw new Error("EmptyListError: List expression cannot be empty");
+		return values.map((e) => handleSimpleExpression(e)).join(",");
+	}
+	return handleSimpleExpression(expr);
+}
+function handleSimpleExpression(expr) {
+	switch (expr.type) {
+		case "any": return "*";
+		case "value": return `${expr.value}`;
+		case "range": {
+			const { min, max } = expr;
+			if (min > max) throw new Error(`OutOfBoundError: Expected ${min} <= ${max}`);
+			return `${min}-${max}`;
+		}
+		case "step": {
+			const { step, range } = expr;
+			if (step === 0) throw new Error(`OutOfBoundError: Expected step value greater than zero`);
+			if (!range) return `*/${step}`;
+			const { min, max } = range;
+			if (max === 0) {
+				if (min > max) throw new Error(`OutOfBoundError: Expected max value greater than zero`);
+				return `${min}-${max}/${step}`;
+			}
+			if (!max) return `${min}/${step}`;
+			if (min > max) throw new Error(`OutOfBoundError: Expected ${min} <= ${max}`);
+			return `${min}-${max}/${step}`;
+		}
+		default: return "*";
+	}
+}
+function generate(fields) {
+	const parts = [];
+	for (let index = 0; index < CRON_FIELD_ORDER.length; index++) {
+		const key = CRON_FIELD_ORDER[index];
+		if (!key) return "";
+		if (key === "second" && !fields[key]) continue;
+		parts.push(fields[key] ?? "*");
+	}
+	return parts.join(" ");
+}
+//#endregion
+//#region src/lib/cron/builder/types.ts
+const WeekDay = {
+	sun: 0,
+	mon: 1,
+	tue: 2,
+	wed: 3,
+	thu: 4,
+	fri: 5,
+	sat: 6
+};
+const Month = {
+	jan: 1,
+	feb: 2,
+	mar: 3,
+	apr: 4,
+	may: 5,
+	jun: 6,
+	jul: 7,
+	aug: 8,
+	sep: 9,
+	oct: 10,
+	nov: 11,
+	dec: 12
+};
+//#endregion
+//#region src/lib/cron/core/scanner.ts
+const FieldAmount = {
+	min: 5,
+	max: 6
+};
+var Token = class {
+	type;
+	component;
+	value;
+	field;
+	constructor(component, type, value, field) {
+		this.component = component;
+		this.type = type;
+		this.value = value;
+		this.field = field;
+	}
+	getComponent() {
+		return this.component;
+	}
+	getTokenType() {
+		return this.type;
+	}
+	getTokenValue() {
+		return this.value;
+	}
+	getField() {
+		return this.field;
+	}
+	toString() {
+		return `Token{${`component="${this.component}", type=${this.type}`}, ${`field="${this.field}", value=${this.value}`}}`;
+	}
+	equals(other) {
+		if (!other) return false;
+		const isComponentEqual = this.component === other.getComponent();
+		const isTokenTypeEqual = this.type === other.getTokenType();
+		const isTokenValueEqual = this.value === other.getTokenValue();
+		const isFieldEqual = this.field === other.getField();
+		return isComponentEqual && isTokenTypeEqual && isTokenValueEqual && isFieldEqual;
+	}
+};
+var Scanner = class {
+	expression;
+	current;
+	start;
+	tokens;
+	constructor(expression) {
+		this.expression = expression;
+		this.current = 0;
+		this.start = 0;
+		this.tokens = [];
+	}
+	scan() {
+		if (this.expression.length === 0) return require_lib_errors_index.err("EmptyCronExpressionError", "Cron expression have zero length");
+		const fields = this.expression.trim().split(/\s+/);
+		const hasMinLen = fields.length === FieldAmount.min;
+		const hasMaxLen = fields.length === FieldAmount.max;
+		if (!hasMinLen && !hasMaxLen) return require_lib_errors_index.err("CronLengthError", `Invalid number of fields for '${this.expression}'. Expected 5 or 6 fields but got ${fields.length} field(s)`);
+		const components = this.createComponent(fields);
+		for (let idx = 0; idx < components.length; idx++) {
+			const component = components[idx];
+			if (!component) return require_lib_errors_index.err("CronExpressionError", `Invalid cron expression: ${this.expression}`);
+			this.current = 0;
+			this.start = 0;
+			const [error, _] = this.scanComponent(component);
+			if (error) return require_lib_errors_index.err(error.type, error.message);
+		}
+		return require_lib_errors_index.ok(this.tokens);
+	}
+	scanComponent(component) {
+		const { field, content } = component;
+		while (this.current < content.length) {
+			let currentCh = this.advance(content);
+			switch (currentCh) {
+				case "*": {
+					const ch = this.peek(content);
+					if (this.match(content, "/")) {
+						const [error, _] = this.handleStep(component);
+						if (error) return require_lib_errors_index.err(error.type, error.message);
+					} else if (!ch || ch === ",") this.addToken("*", "any", "*", field);
+					else return require_lib_errors_index.err("CronExpressionError", `Invalid any expression '${content}' for field '${field}'`);
+					break;
+				}
+				case "-":
+					currentCh = this.advance(content);
+					if (this.isDigit(currentCh)) {
+						const [error, _] = this.handleRangeWithStep(component);
+						if (error) return require_lib_errors_index.err(error.type, error.message);
+					} else return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+					break;
+				case ",": {
+					if (this.current === 1 && this.start === 0) return require_lib_errors_index.err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					const next = this.peek(content);
+					if (!next || next === ",") return require_lib_errors_index.err("CronExpressionError", `Invalid list expression '${content}' for field '${field}'`);
+					break;
+				}
+				default:
+					if (this.isDigit(currentCh)) {
+						const [error, _] = this.handleNumber(component);
+						if (error) return require_lib_errors_index.err(error.type, error.message);
+					} else return require_lib_errors_index.err("CronExpressionError", `Invalid cron expression '${this.expression}' in field '${field}'`);
+					break;
+			}
+			this.start = this.current;
+		}
+		return require_lib_errors_index.ok(true);
+	}
+	addToken(component, type, value, field) {
+		const token = new Token(component, type, value, field);
+		this.tokens.push(token);
+	}
+	advance(content) {
+		const currentCh = content.charAt(this.current);
+		this.current += 1;
+		return currentCh;
+	}
+	match(content, expected) {
+		if (this.current >= content.length) return false;
+		if (content.charAt(this.current) !== expected) return false;
+		this.current += 1;
+		return true;
+	}
+	peek(content) {
+		if (this.current >= content.length) return void 0;
+		return content.charAt(this.current);
+	}
+	handleStep(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		const slashIdx = this.current - 1;
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (ch && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		const tokenContent = content.substring(this.start, this.current);
+		const value = content.slice(slashIdx + 1, this.current);
+		if (value.length === 0) return require_lib_errors_index.err("CronExpressionError", `Invalid step expression '${content}' for field '${field}'`);
+		this.addToken(tokenContent, "step", Number(value), field);
+		return require_lib_errors_index.ok(true);
+	}
+	handleRangeWithStep(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		if (this.match(content, "/")) {
+			const [error, _] = this.handleStep(component);
+			if (error) return require_lib_errors_index.err(error.type, error.message);
+			return require_lib_errors_index.ok(true);
+		}
+		return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+	}
+	handleNumber(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		this.start = this.current - 1;
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) {
+			const item = content.substring(this.start);
+			this.addToken(item, "number", Number(item), field);
+			return require_lib_errors_index.ok(true);
+		}
+		if (this.match(content, "-")) {
+			const [error, _] = this.handleRange(component);
+			if (error) return require_lib_errors_index.err(error.type, error.message);
+			return require_lib_errors_index.ok(true);
+		}
+		if (this.match(content, "/")) {
+			const [error, _] = this.handleStep(component);
+			if (error) return require_lib_errors_index.err(error.type, error.message);
+			return require_lib_errors_index.ok(true);
+		}
+		if (!this.isDigit(ch) && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid number '${content}' for field '${field}'`);
+		const item = content.substring(this.start, this.current);
+		this.addToken(item, "number", Number(item), field);
+		return require_lib_errors_index.ok(true);
+	}
+	handleRange(component) {
+		const { field, content } = component;
+		let ch = this.peek(content);
+		if (!ch) return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		while (ch && this.isDigit(ch)) {
+			this.advance(content);
+			ch = this.peek(content);
+		}
+		if (!ch) {
+			const tokenContent = content.substring(this.start);
+			this.addToken(tokenContent, "range", tokenContent, field);
+			return require_lib_errors_index.ok(true);
+		}
+		if (this.match(content, "/")) {
+			const [error, _] = this.handleStep(component);
+			if (error) return require_lib_errors_index.err(error.type, error.message);
+			return require_lib_errors_index.ok(true);
+		}
+		if (ch && ch !== ",") return require_lib_errors_index.err("CronExpressionError", `Invalid range expression '${content}' for field '${field}'`);
+		const tokenContent = content.substring(this.start, this.current);
+		this.addToken(tokenContent, "range", tokenContent, field);
+		return require_lib_errors_index.ok(true);
+	}
+	isDigit(ch) {
+		return ch >= "0" && ch <= "9";
+	}
+	createComponent(fields) {
+		const fieldNames = [
+			"second",
+			"minute",
+			"hour",
+			"day",
+			"month",
+			"weekday"
+		];
+		const components = [];
+		let offset = 1;
+		if (fields.length === FieldAmount.max) offset = 0;
+		for (let idx = 0; idx < fields.length; idx++) {
+			const fieldName = fieldNames[idx + offset];
+			const content = fields[idx];
+			if (!fieldName || !content) break;
+			components.push({
+				content,
+				field: fieldName
+			});
+		}
+		return components;
+	}
+};
+//#endregion
+//#region src/lib/cron/core/index.ts
 const RETRY_DELAY_MS = 3600 * 1e3;
+const MAX_YEARS = 4;
 const ALIASES = {
 	"@yearly": "0 0 1 1 *",
 	"@monthly": "0 0 1 * *",
@@ -112,9 +531,9 @@ var Cron = class {
 	constructor(options) {
 		this.options = options;
 		const expr = this.resolveAlias(options.schedule);
-		const [error, tokens] = new require_scanner.Scanner(expr).scan();
+		const [error, tokens] = new Scanner(expr).scan();
 		if (error) throw new Error(`${error.type}: ${error.message}`);
-		this.hasSeconds = expr.trim().split(/\s+/).length === require_scanner.FieldAmount.max;
+		this.hasSeconds = expr.trim().split(/\s+/).length === FieldAmount.max;
 		const [parsingError, _] = this.parse(tokens);
 		if (parsingError) throw new Error(`${parsingError.type}: ${parsingError.message}`);
 	}
@@ -207,7 +626,7 @@ var Cron = class {
 		return isSecondMatch && isMinuteMatch && isHourMatch && isDayOrDowMatch && isMonthMatch;
 	}
 	getNextRun() {
-		const date = /* @__PURE__ */ new Date(/* @__PURE__ */ new Date());
+		const date = /* @__PURE__ */ new Date();
 		if (this.hasSeconds) {
 			date.setMilliseconds(0);
 			date.setSeconds(date.getSeconds() + 1);
@@ -215,13 +634,45 @@ var Cron = class {
 			date.setSeconds(0, 0);
 			date.setMinutes(date.getMinutes() + 1);
 		}
-		const maxIterations = this.hasSeconds ? 366 * 4 * 24 * 3600 : 366 * 4 * 24 * 60;
-		for (let i = 0; i < maxIterations; i++) {
-			if (this.matches(date)) {
-				if (date > /* @__PURE__ */ new Date()) return new Date(date);
+		const deadline = new Date(date);
+		deadline.setFullYear(deadline.getFullYear() + MAX_YEARS);
+		while (date < deadline) {
+			const s = date.getSeconds();
+			const m = date.getMinutes();
+			const h = date.getHours();
+			const d = date.getDate();
+			const mon = date.getMonth();
+			const dow = date.getDay();
+			if (this.month[mon + 1] === 0) {
+				date.setDate(1);
+				date.setMonth(mon + 1);
+				date.setHours(0, 0, 0, 0);
+				continue;
+			}
+			let isDayOrDowMatch;
+			if (!this._dayWildcard && !this._dowWildcard) isDayOrDowMatch = this.day[d] === 0 && this.dayOfWeek[dow] === 0;
+			else isDayOrDowMatch = this.day[d] === 0 || this.dayOfWeek[dow] === 0;
+			if (isDayOrDowMatch) {
+				date.setDate(d + 1);
+				date.setHours(0, 0, 0, 0);
+				continue;
+			}
+			if (this.hour[h] === 0) {
+				date.setHours(h + 1);
+				date.setMinutes(0, 0, 0);
+				continue;
+			}
+			if (this.minute[m] === 0) {
+				date.setMinutes(m + 1);
+				date.setSeconds(0, 0);
+				continue;
+			}
+			if (this.hasSeconds && this.second[s] === 0) {
+				date.setSeconds(s + 1);
+				date.setMilliseconds(0);
+				continue;
 			}
-			if (this.hasSeconds) date.setSeconds(date.getSeconds() + 1);
-			else date.setMinutes(date.getMinutes() + 1);
+			return new Date(date);
 		}
 		return null;
 	}
@@ -274,3 +725,11 @@ var Cron = class {
 };
 //#endregion
 exports.Cron = Cron;
+exports.Month = Month;
+exports.WeekDay = WeekDay;
+exports.any = any;
+exports.cronJobBuilder = cronJobBuilder;
+exports.list = list;
+exports.number = number;
+exports.range = range;
+exports.step = step;

package/dist/lib/cron/index.d.cts

@@ -1,6 +1,114 @@
-import { CronOptions, CronStatus } from "../../cron/types.cjs";
-
-//#region src/lib/cron/index.d.ts
+//#region src/lib/cron/builder/types.d.ts
+declare const WeekDay: {
+  readonly sun: 0;
+  readonly mon: 1;
+  readonly tue: 2;
+  readonly wed: 3;
+  readonly thu: 4;
+  readonly fri: 5;
+  readonly sat: 6;
+};
+declare const Month: {
+  readonly jan: 1;
+  readonly feb: 2;
+  readonly mar: 3;
+  readonly apr: 4;
+  readonly may: 5;
+  readonly jun: 6;
+  readonly jul: 7;
+  readonly aug: 8;
+  readonly sep: 9;
+  readonly oct: 10;
+  readonly nov: 11;
+  readonly dec: 12;
+};
+type Enumerate<N extends number, Acc extends number[] = []> = Acc["length"] extends N ? Acc[number] : Enumerate<N, [...Acc, Acc["length"]]>;
+type IntRange<F extends number, T extends number> = Exclude<Enumerate<T>, Enumerate<F>>;
+type TimeType = IntRange<0, 60>;
+type HourType = IntRange<0, 24>;
+type DayType = IntRange<1, 32>;
+type MonthType = IntRange<1, 13>;
+type WeekDayType = IntRange<0, 7>;
+type CronRange<T> = {
+  min: NoInfer<T>;
+  max: NoInfer<T>;
+};
+type CronStep<T> = {
+  step: NoInfer<T>;
+  range?: {
+    min: NoInfer<T>;
+    max?: NoInfer<T>;
+  };
+};
+type CronField = "second" | "minute" | "hour" | "day" | "month" | "weekday";
+type CronListExpr<T> = Exclude<CronExpr<T>, {
+  type: "list";
+}>;
+type CronExpr<T> = {
+  type: "any";
+} | {
+  type: "value";
+  value: T;
+} | {
+  type: "range";
+  min: T;
+  max: T;
+} | {
+  type: "step";
+  step: T;
+  range?: {
+    min: T;
+    max?: T;
+  };
+} | {
+  type: "list";
+  values: CronListExpr<T>[];
+};
+interface IBuilder<Used extends CronField> {
+  second(expr: CronExpr<TimeType>): CronBuilderType<Used | "second">;
+  minute(expr: CronExpr<TimeType>): CronBuilderType<Used | "minute">;
+  hour(expr: CronExpr<HourType>): CronBuilderType<Used | "hour">;
+  day(expr: CronExpr<DayType>): CronBuilderType<Used | "day">;
+  month(expr: CronExpr<MonthType>): CronBuilderType<Used | "month">;
+  weekday(expr: CronExpr<WeekDayType>): CronBuilderType<Used | "weekday">;
+}
+type CronBuilderType<Used extends CronField = never> = Omit<IBuilder<Used>, Used>;
+type BuilderFn = (builder: CronBuilderType) => void;
+//#endregion
+//#region src/lib/cron/builder/index.d.ts
+declare class FieldWrapper<T> {
+  private fields;
+  add(expr: CronListExpr<T>): void;
+  read(): CronListExpr<T>[];
+}
+declare class CronListBuilder<T> {
+  private wrapper;
+  constructor(wrapper: FieldWrapper<T>);
+  any(): CronListBuilder<T>;
+  range(options: CronRange<T>): CronListBuilder<T>;
+  step(options: CronStep<T>): CronListBuilder<T>;
+  number(value: T): CronListBuilder<T>;
+}
+declare function range<T>(options: CronRange<T>): CronExpr<T>;
+declare function any<T>(): CronExpr<T>;
+declare function step<T>(options: CronStep<T>): CronExpr<T>;
+declare function list<T>(builderFn: (builder: CronListBuilder<T>) => CronListBuilder<T>): CronExpr<T>;
+declare function number<T>(value: T): {
+  type: "value";
+  value: T;
+};
+declare function cronJobBuilder(buildFn: BuilderFn): string;
+//#endregion
+//#region src/lib/cron/core/types.d.ts
+type CronAlias = "@yearly" | "@monthly" | "@weekly" | "@daily" | "@hourly" | "@minutely";
+type CronStatus = "idle" | "running" | "paused";
+type CronOptions = {
+  name: string;
+  schedule: CronAlias | (string & {});
+  handler: () => void | Promise<void>;
+};
+//#endregion
+//#region src/lib/cron/core/index.d.ts
 declare class Cron {
   private options;
   private status;
@@ -35,5 +143,4 @@ declare class Cron {
   private run;
 }
 //#endregion
-export { Cron };
-//# sourceMappingURL=index.d.cts.map
+export { Cron, Month, WeekDay, any, cronJobBuilder, list, number, range, step };