# Yahoo! UI Library

### Calendar 2.6.0

Yahoo! UI Library > calendar > DateMath.js (source view)

Show Private Show Protected Show Deprecated

    /**
    * YAHOO.widget.DateMath is used for simple date manipulation. The class is a static utility
    * used for adding, subtracting, and comparing dates.
    * @namespace YAHOO.widget
    * @class DateMath
    */
    YAHOO.widget.DateMath = {
    	/**
    	* Constant field representing Day
    	* @property DAY
    	* @static
    	* @final
    	* @type String
    	*/
    	DAY : "D",

    	/**
    	* Constant field representing Week
    	* @property WEEK
    	* @static
    	* @final
    	* @type String
    	*/
    	WEEK : "W",

    	/**
    	* Constant field representing Year
    	* @property YEAR
    	* @static
    	* @final
    	* @type String
    	*/
    	YEAR : "Y",

    	/**
    	* Constant field representing Month
    	* @property MONTH
    	* @static
    	* @final
    	* @type String
    	*/
    	MONTH : "M",

    	/**
    	* Constant field representing one day, in milliseconds
    	* @property ONE_DAY_MS
    	* @static
    	* @final
    	* @type Number
    	*/
    	ONE_DAY_MS : 1000*60*60*24,

    	/**
    	 * Constant field representing the date in first week of January
    	 * which identifies the first week of the year.
    	 * <p>
    	 * In the U.S, Jan 1st is normally used based on a Sunday start of week.
    	 * ISO 8601, used widely throughout Europe, uses Jan 4th, based on a Monday start of week.
    	 * </p>
    	 * @property WEEK_ONE_JAN_DATE
    	 * @static
    	 * @type Number
    	 */
    	WEEK_ONE_JAN_DATE : 1,

    	/**
    	* Adds the specified amount of time to the this instance.
    	* @method add
    	* @param {Date} date	The JavaScript Date object to perform addition on
    	* @param {String} field	The field constant to be used for performing addition.
    	* @param {Number} amount	The number of units (measured in the field constant) to add to the date.
    	* @return {Date} The resulting Date object
    	*/
    	add : function(date, field, amount) {
    		var d = new Date(date.getTime());
    		switch (field) {
    			case this.MONTH:
    				var newMonth = date.getMonth() + amount;
    				var years = 0;

    				if (newMonth < 0) {
    					while (newMonth < 0) {
    						newMonth += 12;
    						years -= 1;
    					}
    				} else if (newMonth > 11) {
    					while (newMonth > 11) {
    						newMonth -= 12;
    						years += 1;
    					}
    				}

    				d.setMonth(newMonth);
    				d.setFullYear(date.getFullYear() + years);
    				break;
    			case this.DAY:
    				this._addDays(d, amount);
    				// d.setDate(date.getDate() + amount);
    				break;
    			case this.YEAR:
    				d.setFullYear(date.getFullYear() + amount);
    				break;
    			case this.WEEK:
    				this._addDays(d, (amount * 7));
    				// d.setDate(date.getDate() + (amount * 7));
    				break;
    		}
    		return d;
    	},

    	/**
    	 * Private helper method to account for bug in Safari 2 (webkit < 420)
    	 * when Date.setDate(n) is called with n less than -128 or greater than 127.
    	 * <p>
    	 * Fix approach and original findings are available here:
    	 * http://brianary.blogspot.com/2006/03/safari-date-bug.html
    	 * </p>
    	 * @method _addDays
    	 * @param {Date} d JavaScript date object
    	 * @param {Number} nDays The number of days to add to the date object (can be negative)
    	 * @private
    	 */
    	_addDays : function(d, nDays) {
    		if (YAHOO.env.ua.webkit && YAHOO.env.ua.webkit < 420) {
    			if (nDays < 0) {
    				// Ensure we don't go below -128 (getDate() is always 1 to 31, so we won't go above 127)
    				for(var min = -128; nDays < min; nDays -= min) {
    					d.setDate(d.getDate() + min);
    				}
    			} else {
    				// Ensure we don't go above 96 + 31 = 127
    				for(var max = 96; nDays > max; nDays -= max) {
    					d.setDate(d.getDate() + max);
    				}
    			}
    			// nDays should be remainder between -128 and 96
    		}
    		d.setDate(d.getDate() + nDays);
    	},

    	/**
    	* Subtracts the specified amount of time from the this instance.
    	* @method subtract
    	* @param {Date} date	The JavaScript Date object to perform subtraction on
    	* @param {Number} field	The this field constant to be used for performing subtraction.
    	* @param {Number} amount	The number of units (measured in the field constant) to subtract from the date.
    	* @return {Date} The resulting Date object
    	*/
    	subtract : function(date, field, amount) {
    		return this.add(date, field, (amount*-1));
    	},

    	/**
    	* Determines whether a given date is before another date on the calendar.
    	* @method before
    	* @param {Date} date		The Date object to compare with the compare argument
    	* @param {Date} compareTo	The Date object to use for the comparison
    	* @return {Boolean} true if the date occurs before the compared date; false if not.
    	*/
    	before : function(date, compareTo) {
    		var ms = compareTo.getTime();
    		if (date.getTime() < ms) {
    			return true;
    		} else {
    			return false;
    		}
    	},

    	/**
    	* Determines whether a given date is after another date on the calendar.
    	* @method after
    	* @param {Date} date		The Date object to compare with the compare argument
    	* @param {Date} compareTo	The Date object to use for the comparison
    	* @return {Boolean} true if the date occurs after the compared date; false if not.
    	*/
    	after : function(date, compareTo) {
    		var ms = compareTo.getTime();
    		if (date.getTime() > ms) {
    			return true;
    		} else {
    			return false;
    		}
    	},

    	/**
    	* Determines whether a given date is between two other dates on the calendar.
    	* @method between
    	* @param {Date} date		The date to check for
    	* @param {Date} dateBegin	The start of the range
    	* @param {Date} dateEnd		The end of the range
    	* @return {Boolean} true if the date occurs between the compared dates; false if not.
    	*/
    	between : function(date, dateBegin, dateEnd) {
    		if (this.after(date, dateBegin) && this.before(date, dateEnd)) {
    			return true;
    		} else {
    			return false;
    		}
    	},

    	/**
    	* Retrieves a JavaScript Date object representing January 1 of any given year.
    	* @method getJan1
    	* @param {Number} calendarYear		The calendar year for which to retrieve January 1
    	* @return {Date}	January 1 of the calendar year specified.
    	*/
    	getJan1 : function(calendarYear) {
    		return this.getDate(calendarYear,0,1);
    	},

    	/**
    	* Calculates the number of days the specified date is from January 1 of the specified calendar year.
    	* Passing January 1 to this function would return an offset value of zero.
    	* @method getDayOffset
    	* @param {Date}	date	The JavaScript date for which to find the offset
    	* @param {Number} calendarYear	The calendar year to use for determining the offset
    	* @return {Number}	The number of days since January 1 of the given year
    	*/
    	getDayOffset : function(date, calendarYear) {
    		var beginYear = this.getJan1(calendarYear); // Find the start of the year. This will be in week 1.

    		// Find the number of days the passed in date is away from the calendar year start
    		var dayOffset = Math.ceil((date.getTime()-beginYear.getTime()) / this.ONE_DAY_MS);
    		return dayOffset;
    	},

    	/**
    	* Calculates the week number for the given date. Can currently support standard
    	* U.S. week numbers, based on Jan 1st defining the 1st week of the year, and
    	* ISO8601 week numbers, based on Jan 4th defining the 1st week of the year.
    	*
    	* @method getWeekNumber
    	* @param {Date}	date The JavaScript date for which to find the week number
    	* @param {Number} firstDayOfWeek The index of the first day of the week (0 = Sun, 1 = Mon ... 6 = Sat).
    	* Defaults to 0
    	* @param {Number} janDate The date in the first week of January which defines week one for the year
    	* Defaults to the value of YAHOO.widget.DateMath.WEEK_ONE_JAN_DATE, which is 1 (Jan 1st).
    	* For the U.S, this is normally Jan 1st. ISO8601 uses Jan 4th to define the first week of the year.
    	*
    	* @return {Number} The number of the week containing the given date.
    	*/
    	getWeekNumber : function(date, firstDayOfWeek, janDate) {

    		// Setup Defaults
    		firstDayOfWeek = firstDayOfWeek || 0;
    		janDate = janDate || this.WEEK_ONE_JAN_DATE;

    		var targetDate = this.clearTime(date),
    			startOfWeek,
    			endOfWeek;

    		if (targetDate.getDay() === firstDayOfWeek) {
    			startOfWeek = targetDate;
    		} else {
    			startOfWeek = this.getFirstDayOfWeek(targetDate, firstDayOfWeek);
    		}

    		var startYear = startOfWeek.getFullYear(),
    			startTime = startOfWeek.getTime();

    		// DST shouldn't be a problem here, math is quicker than setDate();
    		endOfWeek = new Date(startOfWeek.getTime() + 6*this.ONE_DAY_MS);

    		var weekNum;
    		if (startYear !== endOfWeek.getFullYear() && endOfWeek.getDate() >= janDate) {
    			// If years don't match, endOfWeek is in Jan. and if the
    			// week has WEEK_ONE_JAN_DATE in it, it's week one by definition.
    			weekNum = 1;
    		} else {
    			// Get the 1st day of the 1st week, and
    			// find how many days away we are from it.
    			var weekOne = this.clearTime(this.getDate(startYear, 0, janDate)),
    				weekOneDayOne = this.getFirstDayOfWeek(weekOne, firstDayOfWeek);

    			// Round days to smoothen out 1 hr DST diff
    			var daysDiff  = Math.round((targetDate.getTime() - weekOneDayOne.getTime())/this.ONE_DAY_MS);

    			// Calc. Full Weeks
    			var rem = daysDiff % 7;
    			var weeksDiff = (daysDiff - rem)/7;
    			weekNum = weeksDiff + 1;
    		}
    		return weekNum;
    	},

    	/**
    	 * Get the first day of the week, for the give date.
    	 * @param {Date} dt The date in the week for which the first day is required.
    	 * @param {Number} startOfWeek The index for the first day of the week, 0 = Sun, 1 = Mon ... 6 = Sat (defaults to 0)
    	 * @return {Date} The first day of the week
    	 */
    	getFirstDayOfWeek : function (dt, startOfWeek) {
    		startOfWeek = startOfWeek || 0;
    		var dayOfWeekIndex = dt.getDay(),
    			dayOfWeek = (dayOfWeekIndex - startOfWeek + 7) % 7;

    		return this.subtract(dt, this.DAY, dayOfWeek);
    	},

    	/**
    	* Determines if a given week overlaps two different years.
    	* @method isYearOverlapWeek
    	* @param {Date}	weekBeginDate	The JavaScript Date representing the first day of the week.
    	* @return {Boolean}	true if the date overlaps two different years.
    	*/
    	isYearOverlapWeek : function(weekBeginDate) {
    		var overlaps = false;
    		var nextWeek = this.add(weekBeginDate, this.DAY, 6);
    		if (nextWeek.getFullYear() != weekBeginDate.getFullYear()) {
    			overlaps = true;
    		}
    		return overlaps;
    	},

    	/**
    	* Determines if a given week overlaps two different months.
    	* @method isMonthOverlapWeek
    	* @param {Date}	weekBeginDate	The JavaScript Date representing the first day of the week.
    	* @return {Boolean}	true if the date overlaps two different months.
    	*/
    	isMonthOverlapWeek : function(weekBeginDate) {
    		var overlaps = false;
    		var nextWeek = this.add(weekBeginDate, this.DAY, 6);
    		if (nextWeek.getMonth() != weekBeginDate.getMonth()) {
    			overlaps = true;
    		}
    		return overlaps;
    	},

    	/**
    	* Gets the first day of a month containing a given date.
    	* @method findMonthStart
    	* @param {Date}	date	The JavaScript Date used to calculate the month start
    	* @return {Date}		The JavaScript Date representing the first day of the month
    	*/
    	findMonthStart : function(date) {
    		var start = this.getDate(date.getFullYear(), date.getMonth(), 1);
    		return start;
    	},

    	/**
    	* Gets the last day of a month containing a given date.
    	* @method findMonthEnd
    	* @param {Date}	date	The JavaScript Date used to calculate the month end
    	* @return {Date}		The JavaScript Date representing the last day of the month
    	*/
    	findMonthEnd : function(date) {
    		var start = this.findMonthStart(date);
    		var nextMonth = this.add(start, this.MONTH, 1);
    		var end = this.subtract(nextMonth, this.DAY, 1);
    		return end;
    	},

    	/**
    	* Clears the time fields from a given date, effectively setting the time to 12 noon.
    	* @method clearTime
    	* @param {Date}	date	The JavaScript Date for which the time fields will be cleared
    	* @return {Date}		The JavaScript Date cleared of all time fields
    	*/
    	clearTime : function(date) {
    		date.setHours(12,0,0,0);
    		return date;
    	},

    	/**
    	 * Returns a new JavaScript Date object, representing the given year, month and date. Time fields (hr, min, sec, ms) on the new Date object
    	 * are set to 0. The method allows Date instances to be created with the a year less than 100. "new Date(year, month, date)" implementations
    	 * set the year to 19xx if a year (xx) which is less than 100 is provided.
    	 * <p>
    	 * <em>NOTE:</em>Validation on argument values is not performed. It is the caller's responsibility to ensure
    	 * arguments are valid as per the ECMAScript-262 Date object specification for the new Date(year, month[, date]) constructor.
    	 * </p>
    	 * @method getDate
    	 * @param {Number} y Year.
    	 * @param {Number} m Month index from 0 (Jan) to 11 (Dec).
    	 * @param {Number} d (optional) Date from 1 to 31. If not provided, defaults to 1.
    	 * @return {Date} The JavaScript date object with year, month, date set as provided.
    	 */
    	getDate : function(y, m, d) {
    		var dt = null;
    		if (YAHOO.lang.isUndefined(d)) {
    			d = 1;
    		}
    		if (y >= 100) {
    			dt = new Date(y, m, d);
    		} else {
    			dt = new Date();
    			dt.setFullYear(y);
    			dt.setMonth(m);
    			dt.setDate(d);
    			dt.setHours(0,0,0,0);
    		}
    		return dt;
    	}
    };

Copyright © 2008 Yahoo! Inc. All rights reserved.