Mercurial > kallithea
comparison pylons_app/public/js/yui/datemath/datemath-debug.js @ 0:564e40829f80
initial commit.
author | Marcin Kuzminski |
---|---|
date | Thu, 18 Feb 2010 13:01:57 +0100 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:564e40829f80 |
---|---|
1 /* | |
2 Copyright (c) 2009, Yahoo! Inc. All rights reserved. | |
3 Code licensed under the BSD License: | |
4 http://developer.yahoo.net/yui/license.txt | |
5 version: 2.8.0r4 | |
6 */ | |
7 /** | |
8 * The datemath module provides utility methods for basic JavaScript Date object manipulation and | |
9 * comparison. | |
10 * | |
11 * @module datemath | |
12 */ | |
13 | |
14 /** | |
15 * YAHOO.widget.DateMath is used for simple date manipulation. The class is a static utility | |
16 * used for adding, subtracting, and comparing dates. | |
17 * @namespace YAHOO.widget | |
18 * @class DateMath | |
19 */ | |
20 YAHOO.widget.DateMath = { | |
21 /** | |
22 * Constant field representing Day | |
23 * @property DAY | |
24 * @static | |
25 * @final | |
26 * @type String | |
27 */ | |
28 DAY : "D", | |
29 | |
30 /** | |
31 * Constant field representing Week | |
32 * @property WEEK | |
33 * @static | |
34 * @final | |
35 * @type String | |
36 */ | |
37 WEEK : "W", | |
38 | |
39 /** | |
40 * Constant field representing Year | |
41 * @property YEAR | |
42 * @static | |
43 * @final | |
44 * @type String | |
45 */ | |
46 YEAR : "Y", | |
47 | |
48 /** | |
49 * Constant field representing Month | |
50 * @property MONTH | |
51 * @static | |
52 * @final | |
53 * @type String | |
54 */ | |
55 MONTH : "M", | |
56 | |
57 /** | |
58 * Constant field representing one day, in milliseconds | |
59 * @property ONE_DAY_MS | |
60 * @static | |
61 * @final | |
62 * @type Number | |
63 */ | |
64 ONE_DAY_MS : 1000*60*60*24, | |
65 | |
66 /** | |
67 * Constant field representing the date in first week of January | |
68 * which identifies the first week of the year. | |
69 * <p> | |
70 * In the U.S, Jan 1st is normally used based on a Sunday start of week. | |
71 * ISO 8601, used widely throughout Europe, uses Jan 4th, based on a Monday start of week. | |
72 * </p> | |
73 * @property WEEK_ONE_JAN_DATE | |
74 * @static | |
75 * @type Number | |
76 */ | |
77 WEEK_ONE_JAN_DATE : 1, | |
78 | |
79 /** | |
80 * Adds the specified amount of time to the this instance. | |
81 * @method add | |
82 * @param {Date} date The JavaScript Date object to perform addition on | |
83 * @param {String} field The field constant to be used for performing addition. | |
84 * @param {Number} amount The number of units (measured in the field constant) to add to the date. | |
85 * @return {Date} The resulting Date object | |
86 */ | |
87 add : function(date, field, amount) { | |
88 var d = new Date(date.getTime()); | |
89 switch (field) { | |
90 case this.MONTH: | |
91 var newMonth = date.getMonth() + amount; | |
92 var years = 0; | |
93 | |
94 if (newMonth < 0) { | |
95 while (newMonth < 0) { | |
96 newMonth += 12; | |
97 years -= 1; | |
98 } | |
99 } else if (newMonth > 11) { | |
100 while (newMonth > 11) { | |
101 newMonth -= 12; | |
102 years += 1; | |
103 } | |
104 } | |
105 | |
106 d.setMonth(newMonth); | |
107 d.setFullYear(date.getFullYear() + years); | |
108 break; | |
109 case this.DAY: | |
110 this._addDays(d, amount); | |
111 // d.setDate(date.getDate() + amount); | |
112 break; | |
113 case this.YEAR: | |
114 d.setFullYear(date.getFullYear() + amount); | |
115 break; | |
116 case this.WEEK: | |
117 this._addDays(d, (amount * 7)); | |
118 // d.setDate(date.getDate() + (amount * 7)); | |
119 break; | |
120 } | |
121 return d; | |
122 }, | |
123 | |
124 /** | |
125 * Private helper method to account for bug in Safari 2 (webkit < 420) | |
126 * when Date.setDate(n) is called with n less than -128 or greater than 127. | |
127 * <p> | |
128 * Fix approach and original findings are available here: | |
129 * http://brianary.blogspot.com/2006/03/safari-date-bug.html | |
130 * </p> | |
131 * @method _addDays | |
132 * @param {Date} d JavaScript date object | |
133 * @param {Number} nDays The number of days to add to the date object (can be negative) | |
134 * @private | |
135 */ | |
136 _addDays : function(d, nDays) { | |
137 if (YAHOO.env.ua.webkit && YAHOO.env.ua.webkit < 420) { | |
138 if (nDays < 0) { | |
139 // Ensure we don't go below -128 (getDate() is always 1 to 31, so we won't go above 127) | |
140 for(var min = -128; nDays < min; nDays -= min) { | |
141 d.setDate(d.getDate() + min); | |
142 } | |
143 } else { | |
144 // Ensure we don't go above 96 + 31 = 127 | |
145 for(var max = 96; nDays > max; nDays -= max) { | |
146 d.setDate(d.getDate() + max); | |
147 } | |
148 } | |
149 // nDays should be remainder between -128 and 96 | |
150 } | |
151 d.setDate(d.getDate() + nDays); | |
152 }, | |
153 | |
154 /** | |
155 * Subtracts the specified amount of time from the this instance. | |
156 * @method subtract | |
157 * @param {Date} date The JavaScript Date object to perform subtraction on | |
158 * @param {Number} field The this field constant to be used for performing subtraction. | |
159 * @param {Number} amount The number of units (measured in the field constant) to subtract from the date. | |
160 * @return {Date} The resulting Date object | |
161 */ | |
162 subtract : function(date, field, amount) { | |
163 return this.add(date, field, (amount*-1)); | |
164 }, | |
165 | |
166 /** | |
167 * Determines whether a given date is before another date on the calendar. | |
168 * @method before | |
169 * @param {Date} date The Date object to compare with the compare argument | |
170 * @param {Date} compareTo The Date object to use for the comparison | |
171 * @return {Boolean} true if the date occurs before the compared date; false if not. | |
172 */ | |
173 before : function(date, compareTo) { | |
174 var ms = compareTo.getTime(); | |
175 if (date.getTime() < ms) { | |
176 return true; | |
177 } else { | |
178 return false; | |
179 } | |
180 }, | |
181 | |
182 /** | |
183 * Determines whether a given date is after another date on the calendar. | |
184 * @method after | |
185 * @param {Date} date The Date object to compare with the compare argument | |
186 * @param {Date} compareTo The Date object to use for the comparison | |
187 * @return {Boolean} true if the date occurs after the compared date; false if not. | |
188 */ | |
189 after : function(date, compareTo) { | |
190 var ms = compareTo.getTime(); | |
191 if (date.getTime() > ms) { | |
192 return true; | |
193 } else { | |
194 return false; | |
195 } | |
196 }, | |
197 | |
198 /** | |
199 * Determines whether a given date is between two other dates on the calendar. | |
200 * @method between | |
201 * @param {Date} date The date to check for | |
202 * @param {Date} dateBegin The start of the range | |
203 * @param {Date} dateEnd The end of the range | |
204 * @return {Boolean} true if the date occurs between the compared dates; false if not. | |
205 */ | |
206 between : function(date, dateBegin, dateEnd) { | |
207 if (this.after(date, dateBegin) && this.before(date, dateEnd)) { | |
208 return true; | |
209 } else { | |
210 return false; | |
211 } | |
212 }, | |
213 | |
214 /** | |
215 * Retrieves a JavaScript Date object representing January 1 of any given year. | |
216 * @method getJan1 | |
217 * @param {Number} calendarYear The calendar year for which to retrieve January 1 | |
218 * @return {Date} January 1 of the calendar year specified. | |
219 */ | |
220 getJan1 : function(calendarYear) { | |
221 return this.getDate(calendarYear,0,1); | |
222 }, | |
223 | |
224 /** | |
225 * Calculates the number of days the specified date is from January 1 of the specified calendar year. | |
226 * Passing January 1 to this function would return an offset value of zero. | |
227 * @method getDayOffset | |
228 * @param {Date} date The JavaScript date for which to find the offset | |
229 * @param {Number} calendarYear The calendar year to use for determining the offset | |
230 * @return {Number} The number of days since January 1 of the given year | |
231 */ | |
232 getDayOffset : function(date, calendarYear) { | |
233 var beginYear = this.getJan1(calendarYear); // Find the start of the year. This will be in week 1. | |
234 | |
235 // Find the number of days the passed in date is away from the calendar year start | |
236 var dayOffset = Math.ceil((date.getTime()-beginYear.getTime()) / this.ONE_DAY_MS); | |
237 return dayOffset; | |
238 }, | |
239 | |
240 /** | |
241 * Calculates the week number for the given date. Can currently support standard | |
242 * U.S. week numbers, based on Jan 1st defining the 1st week of the year, and | |
243 * ISO8601 week numbers, based on Jan 4th defining the 1st week of the year. | |
244 * | |
245 * @method getWeekNumber | |
246 * @param {Date} date The JavaScript date for which to find the week number | |
247 * @param {Number} firstDayOfWeek The index of the first day of the week (0 = Sun, 1 = Mon ... 6 = Sat). | |
248 * Defaults to 0 | |
249 * @param {Number} janDate The date in the first week of January which defines week one for the year | |
250 * Defaults to the value of YAHOO.widget.DateMath.WEEK_ONE_JAN_DATE, which is 1 (Jan 1st). | |
251 * For the U.S, this is normally Jan 1st. ISO8601 uses Jan 4th to define the first week of the year. | |
252 * | |
253 * @return {Number} The number of the week containing the given date. | |
254 */ | |
255 getWeekNumber : function(date, firstDayOfWeek, janDate) { | |
256 | |
257 // Setup Defaults | |
258 firstDayOfWeek = firstDayOfWeek || 0; | |
259 janDate = janDate || this.WEEK_ONE_JAN_DATE; | |
260 | |
261 var targetDate = this.clearTime(date), | |
262 startOfWeek, | |
263 endOfWeek; | |
264 | |
265 if (targetDate.getDay() === firstDayOfWeek) { | |
266 startOfWeek = targetDate; | |
267 } else { | |
268 startOfWeek = this.getFirstDayOfWeek(targetDate, firstDayOfWeek); | |
269 } | |
270 | |
271 var startYear = startOfWeek.getFullYear(); | |
272 | |
273 // DST shouldn't be a problem here, math is quicker than setDate(); | |
274 endOfWeek = new Date(startOfWeek.getTime() + 6*this.ONE_DAY_MS); | |
275 | |
276 var weekNum; | |
277 if (startYear !== endOfWeek.getFullYear() && endOfWeek.getDate() >= janDate) { | |
278 // If years don't match, endOfWeek is in Jan. and if the | |
279 // week has WEEK_ONE_JAN_DATE in it, it's week one by definition. | |
280 weekNum = 1; | |
281 } else { | |
282 // Get the 1st day of the 1st week, and | |
283 // find how many days away we are from it. | |
284 var weekOne = this.clearTime(this.getDate(startYear, 0, janDate)), | |
285 weekOneDayOne = this.getFirstDayOfWeek(weekOne, firstDayOfWeek); | |
286 | |
287 // Round days to smoothen out 1 hr DST diff | |
288 var daysDiff = Math.round((targetDate.getTime() - weekOneDayOne.getTime())/this.ONE_DAY_MS); | |
289 | |
290 // Calc. Full Weeks | |
291 var rem = daysDiff % 7; | |
292 var weeksDiff = (daysDiff - rem)/7; | |
293 weekNum = weeksDiff + 1; | |
294 } | |
295 return weekNum; | |
296 }, | |
297 | |
298 /** | |
299 * Get the first day of the week, for the give date. | |
300 * @param {Date} dt The date in the week for which the first day is required. | |
301 * @param {Number} startOfWeek The index for the first day of the week, 0 = Sun, 1 = Mon ... 6 = Sat (defaults to 0) | |
302 * @return {Date} The first day of the week | |
303 */ | |
304 getFirstDayOfWeek : function (dt, startOfWeek) { | |
305 startOfWeek = startOfWeek || 0; | |
306 var dayOfWeekIndex = dt.getDay(), | |
307 dayOfWeek = (dayOfWeekIndex - startOfWeek + 7) % 7; | |
308 | |
309 return this.subtract(dt, this.DAY, dayOfWeek); | |
310 }, | |
311 | |
312 /** | |
313 * Determines if a given week overlaps two different years. | |
314 * @method isYearOverlapWeek | |
315 * @param {Date} weekBeginDate The JavaScript Date representing the first day of the week. | |
316 * @return {Boolean} true if the date overlaps two different years. | |
317 */ | |
318 isYearOverlapWeek : function(weekBeginDate) { | |
319 var overlaps = false; | |
320 var nextWeek = this.add(weekBeginDate, this.DAY, 6); | |
321 if (nextWeek.getFullYear() != weekBeginDate.getFullYear()) { | |
322 overlaps = true; | |
323 } | |
324 return overlaps; | |
325 }, | |
326 | |
327 /** | |
328 * Determines if a given week overlaps two different months. | |
329 * @method isMonthOverlapWeek | |
330 * @param {Date} weekBeginDate The JavaScript Date representing the first day of the week. | |
331 * @return {Boolean} true if the date overlaps two different months. | |
332 */ | |
333 isMonthOverlapWeek : function(weekBeginDate) { | |
334 var overlaps = false; | |
335 var nextWeek = this.add(weekBeginDate, this.DAY, 6); | |
336 if (nextWeek.getMonth() != weekBeginDate.getMonth()) { | |
337 overlaps = true; | |
338 } | |
339 return overlaps; | |
340 }, | |
341 | |
342 /** | |
343 * Gets the first day of a month containing a given date. | |
344 * @method findMonthStart | |
345 * @param {Date} date The JavaScript Date used to calculate the month start | |
346 * @return {Date} The JavaScript Date representing the first day of the month | |
347 */ | |
348 findMonthStart : function(date) { | |
349 var start = this.getDate(date.getFullYear(), date.getMonth(), 1); | |
350 return start; | |
351 }, | |
352 | |
353 /** | |
354 * Gets the last day of a month containing a given date. | |
355 * @method findMonthEnd | |
356 * @param {Date} date The JavaScript Date used to calculate the month end | |
357 * @return {Date} The JavaScript Date representing the last day of the month | |
358 */ | |
359 findMonthEnd : function(date) { | |
360 var start = this.findMonthStart(date); | |
361 var nextMonth = this.add(start, this.MONTH, 1); | |
362 var end = this.subtract(nextMonth, this.DAY, 1); | |
363 return end; | |
364 }, | |
365 | |
366 /** | |
367 * Clears the time fields from a given date, effectively setting the time to 12 noon. | |
368 * @method clearTime | |
369 * @param {Date} date The JavaScript Date for which the time fields will be cleared | |
370 * @return {Date} The JavaScript Date cleared of all time fields | |
371 */ | |
372 clearTime : function(date) { | |
373 date.setHours(12,0,0,0); | |
374 return date; | |
375 }, | |
376 | |
377 /** | |
378 * Returns a new JavaScript Date object, representing the given year, month and date. Time fields (hr, min, sec, ms) on the new Date object | |
379 * 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 | |
380 * set the year to 19xx if a year (xx) which is less than 100 is provided. | |
381 * <p> | |
382 * <em>NOTE:</em>Validation on argument values is not performed. It is the caller's responsibility to ensure | |
383 * arguments are valid as per the ECMAScript-262 Date object specification for the new Date(year, month[, date]) constructor. | |
384 * </p> | |
385 * @method getDate | |
386 * @param {Number} y Year. | |
387 * @param {Number} m Month index from 0 (Jan) to 11 (Dec). | |
388 * @param {Number} d (optional) Date from 1 to 31. If not provided, defaults to 1. | |
389 * @return {Date} The JavaScript date object with year, month, date set as provided. | |
390 */ | |
391 getDate : function(y, m, d) { | |
392 var dt = null; | |
393 if (YAHOO.lang.isUndefined(d)) { | |
394 d = 1; | |
395 } | |
396 if (y >= 100) { | |
397 dt = new Date(y, m, d); | |
398 } else { | |
399 dt = new Date(); | |
400 dt.setFullYear(y); | |
401 dt.setMonth(m); | |
402 dt.setDate(d); | |
403 dt.setHours(0,0,0,0); | |
404 } | |
405 return dt; | |
406 } | |
407 }; | |
408 YAHOO.register("datemath", YAHOO.widget.DateMath, {version: "2.8.0r4", build: "2449"}); |