FM / src

/usr/local/lib/node_modules/pm2/node_modules/croner/src/

/usr/local/lib/node_modules/pm2/node_modules/croner/src

Name	Size	Mode	Actions
croner.js	9090	0644	edit dl rm
croner.single.js	53	0644	edit dl rm
date.js	9663	0644	edit dl rm
pattern.js	10832	0644	edit dl rm
timezone.js	892	0644	edit dl rm

Edit: /usr/local/lib/node_modules/pm2/node_modules/croner/src/date.js (9663B)

import convertTZ from "./timezone.js";

/**
 * Converts date to CronDate
 * @constructor
 * 
 * @param {CronDate|date|string} [date] - Input date, if using string representation ISO 8001 (2015-11-24T19:40:00) local timezone is expected
 * @param {string} [timezone] - String representation of target timezone in Europe/Stockholm format.
 */
function CronDate (date, timezone) {

this.timezone = timezone;

if (date && date instanceof Date) {
		this.fromDate(date);
	} else if (date === void 0) {
		this.fromDate(new Date());
	} else if (date && typeof date === "string") {
		this.fromString(date);
	} else if (date instanceof CronDate) {
		this.fromCronDate(date);
	} else {
		throw new TypeError("CronDate: Invalid type (" + typeof date + ") passed as parameter to CronDate constructor");
	}
}

/**
 * Sets internals using a Date 
 * @private
 * 
 * @param {Date} date - Input date
 */
CronDate.prototype.fromDate = function (date) {
	
	if (this.timezone) {
		date = convertTZ(date, this.timezone);
	}

this.milliseconds = date.getMilliseconds();
	this.seconds = date.getSeconds();
	this.minutes = date.getMinutes();
	this.hours = date.getHours();
	this.days = date.getDate();
	this.months  = date.getMonth();
	this.years = date.getFullYear();

};

/**
 * Sets internals by deep copying another CronDate
 * @private
 * 
 * @param {CronDate} date - Input date
 */
CronDate.prototype.fromCronDate = function (date) {
	this.timezone = date.timezone;
	this.milliseconds = date.milliseconds;
	this.seconds = date.seconds;
	this.minutes = date.minutes;
	this.hours = date.hours;
	this.days = date.days;
	this.months = date.months;
	this.years = date.years;
};

/**
 * Reset internal parameters (seconds, minutes, hours) that may have exceeded their ranges
 * @private
 * 
 * @param {Date} date - Input date
 */
CronDate.prototype.apply = function () {
	const newDate = new Date(this.years, this.months, this.days, this.hours, this.minutes, this.seconds, this.milliseconds);
	
	this.milliseconds = newDate.getMilliseconds();
	this.seconds = newDate.getSeconds();
	this.minutes = newDate.getMinutes();
	this.hours = newDate.getHours();
	this.days = newDate.getDate();
	this.months  = newDate.getMonth();
	this.years = newDate.getFullYear();
};

/**
 * Sets internals by parsing a string
 * @private
 * 
 * @param {Date} date - Input date
 */
CronDate.prototype.fromString = function (str) {

const parsedDate = this.parseISOLocal(str);

// Throw if we did get an invalid date
	if( isNaN(parsedDate) ) {
		throw new TypeError("CronDate: Provided string value for CronDate could not be parsed as date.");
	}
	
	this.fromDate(parsedDate);
};

/**
 * Increment to next run time
 * @public
 * 
 * @param {string} pattern - The pattern used to increment current state
 * @param {boolean} [rerun=false] - If this is an internal incremental run
 * @return {CronDate|null} - Returns itself for chaining, or null if increment wasnt possible
 */
CronDate.prototype.increment = function (pattern, rerun) {

if (!rerun) {
		this.seconds += 1;
	}

this.milliseconds = 0;

const 
		origTime = this.getTime(),
		
		/**
		 * Find next
		 * 
		 * @param {string} target
		 * @param {string} pattern
		 * @param {string} offset
		 * @param {string} override
		 * 
		 * @returns {boolean}
		 * 
		 */
		findNext = (target, pattern, offset, override) => {
			
			const startPos = (override === void 0) ? this[target] + offset : 0 + offset;

for( let i = startPos; i < pattern[target].length; i++ ) {

// If pattern matches and, in case of days, weekday matches, go on
				if( pattern[target][i] ) {
					
					// Special handling for L (last day of month), when we are searching for days
					if (target === "days" && pattern.lastDayOfMonth) {
						let baseDate = this.getDate(true);

// Set days to one day after today, if month changes, then we are at the last day of the month
						baseDate.setDate(i-offset+1);
						if (baseDate.getMonth() !== this["months"]) {
							this[target] = i-offset;
							return true;
						}
					
					// Normal handling
					} else {
						this[target] = i-offset;
						return true;
					}

}
			}
			return false;

},
		
		resetPrevious = (offset) => {
			// Now when we have gone to next minute, we have to set seconds to the first match
			// Now we are at 00:01:05 following the same example.
			// 
			// This goes all the way back to seconds, hence the reverse loop.
			while(doing + offset >= 0) {

// Ok, reset current member(e.g. seconds) to first match in pattern, using 
				// the same method as aerlier
				// 
				// Note the fourth parameter, stating that we should start matching the pattern
				// from zero, instead of current time.
				findNext(toDo[doing + offset][0], pattern, toDo[doing + offset][2], 0);

// Go back up, days -> hours -> minutes -> seconds
				doing--;
			}
		};

// Array of work to be done, consisting of subarrays described below:
	// [
	//   First item is which member to process,
	//   Second item is which member to increment if we didn't find a mathch in current item,
	//   Third item is an offset. if months is handled 0-11 in js date object, and we get 1-12
	//   from pattern. Offset should be -1
	// ]
	const toDo = [
		["seconds", "minutes", 0],
		["minutes", "hours", 0],
		["hours", "days", 0],
		["days", "months", -1],
		["months", "years", 0]
	];

// Ok, we're working our way trough the toDo array, top to bottom
	// If we reach 5, work is done
	let doing = 0;
	while(doing < 5) {

// findNext sets the current member to next match in pattern
		// If time is 00:00:01 and pattern says *:*:05, seconds will
		// be set to 5

// Store current value at current level
		let currentValue = this[toDo[doing][0]];
		
		// If pattern didn't provide a match, increment next value (e.g. minues)
		if(!findNext(toDo[doing][0], pattern, toDo[doing][2])) {
			this[toDo[doing][1]]++;

// Reset current level and previous levels
			resetPrevious(0);

// If pattern provided a match, but changed current value ...
		} else if (currentValue !== this[toDo[doing][0]]) {
			// Reset previous levels
			resetPrevious(-1);

}

// Bail out if an impossible pattern is used
		if (this.years >= 4000) {
			return null;
		}

// Gp down, seconds -> minutes -> hours -> days -> months -> year
		doing++;
	}
	
	// This is a special case for weekday, as the user isn't able to combine date/month patterns 
	// with weekday patterns, it's just to increment days until we get a match.
	while (!pattern.daysOfWeek[this.getDate(true).getDay()]) {
		this.days += 1;

// Reset everything before days
		doing = 2;
		resetPrevious();
	}

// If anything changed, recreate this CronDate and run again without incrementing
	if (origTime != this.getTime()) {
		this.apply();
		return this.increment(pattern, true);
	} else {
		return this;
	}

};

/**
 * Convert current state back to a javascript Date()
 * @public
 * 
 * @param {boolean} internal - If this is an internal call
 * @returns {Date}
 */
CronDate.prototype.getDate = function (internal) {
	const targetDate = new Date(this.years, this.months, this.days, this.hours, this.minutes, this.seconds, this.milliseconds);
	if (internal || !this.timezone) {
		return targetDate;
	} else {
		const offset = convertTZ(targetDate, this.timezone).getTime()-targetDate.getTime();
		return new Date(targetDate.getTime()-offset);
	}
};

/**
 * Convert current state back to a javascript Date() and return UTC milliseconds
 * @public
 * 
 * @param {boolean} internal - If this is an internal call
 * @returns {Date}
 */
CronDate.prototype.getTime = function (internal) {
	return this.getDate(internal).getTime();
};

/**
 * Takes a iso 8001 local date time string and creates a Date object
 * @private
 * 
 * @param {string} dateTimeString - an ISO 8001 format date and time string
 *                      with all components, e.g. 2015-11-24T19:40:00
 * @returns {Date|number} - Date instance from parsing the string. May be NaN.
 */
CronDate.prototype.parseISOLocal = function (dateTimeString) {
	const dateTimeStringSplit = dateTimeString.split(/\D/);

// Check for completeness
	if (dateTimeStringSplit.length < 6) {
		return NaN;
	}

const
		year = parseInt(dateTimeStringSplit[0], 10),
		month = parseInt(dateTimeStringSplit[1], 10),
		day = parseInt(dateTimeStringSplit[2], 10),
		hour = parseInt(dateTimeStringSplit[3], 10),
		minute = parseInt(dateTimeStringSplit[4], 10),
		second = parseInt(dateTimeStringSplit[5], 10);

// Check parts for numeric
	if( isNaN(year) || isNaN(month) || isNaN(day) || isNaN(hour) || isNaN(minute) || isNaN(second) ) {
		return NaN;
	} else {
		let generatedDate;

// Check for UTC flag
		if ((dateTimeString.indexOf("Z") > 0)) {

// Handle date as UTC
			generatedDate = new Date(Date.UTC(year, month-1, day, hour, minute, second));

// Check generated date
			if (year == generatedDate.getUTCFullYear()
				&& month == generatedDate.getUTCMonth()+1
				&& day == generatedDate.getUTCDate()
				&& hour == generatedDate.getUTCHours()
				&& minute == generatedDate.getUTCMinutes()
				&& second == generatedDate.getUTCSeconds()) {
				return generatedDate;
			} else {
				return NaN;
			}
		} else {

// Handle date as local time
			generatedDate = new Date(year, month-1, day, hour, minute, second);

// Check generated date
			if (year == generatedDate.getFullYear()
				&& month == generatedDate.getMonth()+1
				&& day == generatedDate.getDate()
				&& hour == generatedDate.getHours()
				&& minute == generatedDate.getMinutes()
				&& second == generatedDate.getSeconds()) {
				return generatedDate;
			} else {
				return NaN;
			}
		}
	}
};

export { CronDate };

cmd: