From 1354d17270961fff662d40f90521223f8fd0d73b Mon Sep 17 00:00:00 2001 From: Andrew Dolgov Date: Tue, 14 Aug 2012 18:59:10 +0400 Subject: update dojo to 1.7.3 --- lib/dojo/date.js.uncompressed.js | 347 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 347 insertions(+) create mode 100644 lib/dojo/date.js.uncompressed.js (limited to 'lib/dojo/date.js.uncompressed.js') diff --git a/lib/dojo/date.js.uncompressed.js b/lib/dojo/date.js.uncompressed.js new file mode 100644 index 000000000..423561754 --- /dev/null +++ b/lib/dojo/date.js.uncompressed.js @@ -0,0 +1,347 @@ +define("dojo/date", ["./_base/kernel", "./_base/lang"], function(dojo, lang) { + // module: + // dojo/date + // summary: + // TODOC + +lang.getObject("date", true, dojo); + +/*===== +dojo.date = { + // summary: Date manipulation utilities +} +=====*/ + +dojo.date.getDaysInMonth = function(/*Date*/dateObject){ + // summary: + // Returns the number of days in the month used by dateObject + var month = dateObject.getMonth(); + var days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + if(month == 1 && dojo.date.isLeapYear(dateObject)){ return 29; } // Number + return days[month]; // Number +}; + +dojo.date.isLeapYear = function(/*Date*/dateObject){ + // summary: + // Determines if the year of the dateObject is a leap year + // description: + // Leap years are years with an additional day YYYY-02-29, where the + // year number is a multiple of four with the following exception: If + // a year is a multiple of 100, then it is only a leap year if it is + // also a multiple of 400. For example, 1900 was not a leap year, but + // 2000 is one. + + var year = dateObject.getFullYear(); + return !(year%400) || (!(year%4) && !!(year%100)); // Boolean +}; + +// FIXME: This is not localized +dojo.date.getTimezoneName = function(/*Date*/dateObject){ + // summary: + // Get the user's time zone as provided by the browser + // dateObject: + // Needed because the timezone may vary with time (daylight savings) + // description: + // Try to get time zone info from toString or toLocaleString method of + // the Date object -- UTC offset is not a time zone. See + // http://www.twinsun.com/tz/tz-link.htm Note: results may be + // inconsistent across browsers. + + var str = dateObject.toString(); // Start looking in toString + var tz = ''; // The result -- return empty string if nothing found + var match; + + // First look for something in parentheses -- fast lookup, no regex + var pos = str.indexOf('('); + if(pos > -1){ + tz = str.substring(++pos, str.indexOf(')')); + }else{ + // If at first you don't succeed ... + // If IE knows about the TZ, it appears before the year + // Capital letters or slash before a 4-digit year + // at the end of string + var pat = /([A-Z\/]+) \d{4}$/; + if((match = str.match(pat))){ + tz = match[1]; + }else{ + // Some browsers (e.g. Safari) glue the TZ on the end + // of toLocaleString instead of putting it in toString + str = dateObject.toLocaleString(); + // Capital letters or slash -- end of string, + // after space + pat = / ([A-Z\/]+)$/; + if((match = str.match(pat))){ + tz = match[1]; + } + } + } + + // Make sure it doesn't somehow end up return AM or PM + return (tz == 'AM' || tz == 'PM') ? '' : tz; // String +}; + +// Utility methods to do arithmetic calculations with Dates + +dojo.date.compare = function(/*Date*/date1, /*Date?*/date2, /*String?*/portion){ + // summary: + // Compare two date objects by date, time, or both. + // description: + // Returns 0 if equal, positive if a > b, else negative. + // date1: + // Date object + // date2: + // Date object. If not specified, the current Date is used. + // portion: + // A string indicating the "date" or "time" portion of a Date object. + // Compares both "date" and "time" by default. One of the following: + // "date", "time", "datetime" + + // Extra step required in copy for IE - see #3112 + date1 = new Date(+date1); + date2 = new Date(+(date2 || new Date())); + + if(portion == "date"){ + // Ignore times and compare dates. + date1.setHours(0, 0, 0, 0); + date2.setHours(0, 0, 0, 0); + }else if(portion == "time"){ + // Ignore dates and compare times. + date1.setFullYear(0, 0, 0); + date2.setFullYear(0, 0, 0); + } + + if(date1 > date2){ return 1; } // int + if(date1 < date2){ return -1; } // int + return 0; // int +}; + +dojo.date.add = function(/*Date*/date, /*String*/interval, /*int*/amount){ + // summary: + // Add to a Date in intervals of different size, from milliseconds to years + // date: Date + // Date object to start with + // interval: + // A string representing the interval. One of the following: + // "year", "month", "day", "hour", "minute", "second", + // "millisecond", "quarter", "week", "weekday" + // amount: + // How much to add to the date. + + var sum = new Date(+date); // convert to Number before copying to accomodate IE (#3112) + var fixOvershoot = false; + var property = "Date"; + + switch(interval){ + case "day": + break; + case "weekday": + //i18n FIXME: assumes Saturday/Sunday weekend, but this is not always true. see dojo.cldr.supplemental + + // Divide the increment time span into weekspans plus leftover days + // e.g., 8 days is one 5-day weekspan / and two leftover days + // Can't have zero leftover days, so numbers divisible by 5 get + // a days value of 5, and the remaining days make up the number of weeks + var days, weeks; + var mod = amount % 5; + if(!mod){ + days = (amount > 0) ? 5 : -5; + weeks = (amount > 0) ? ((amount-5)/5) : ((amount+5)/5); + }else{ + days = mod; + weeks = parseInt(amount/5); + } + // Get weekday value for orig date param + var strt = date.getDay(); + // Orig date is Sat / positive incrementer + // Jump over Sun + var adj = 0; + if(strt == 6 && amount > 0){ + adj = 1; + }else if(strt == 0 && amount < 0){ + // Orig date is Sun / negative incrementer + // Jump back over Sat + adj = -1; + } + // Get weekday val for the new date + var trgt = strt + days; + // New date is on Sat or Sun + if(trgt == 0 || trgt == 6){ + adj = (amount > 0) ? 2 : -2; + } + // Increment by number of weeks plus leftover days plus + // weekend adjustments + amount = (7 * weeks) + days + adj; + break; + case "year": + property = "FullYear"; + // Keep increment/decrement from 2/29 out of March + fixOvershoot = true; + break; + case "week": + amount *= 7; + break; + case "quarter": + // Naive quarter is just three months + amount *= 3; + // fallthrough... + case "month": + // Reset to last day of month if you overshoot + fixOvershoot = true; + property = "Month"; + break; +// case "hour": +// case "minute": +// case "second": +// case "millisecond": + default: + property = "UTC"+interval.charAt(0).toUpperCase() + interval.substring(1) + "s"; + } + + if(property){ + sum["set"+property](sum["get"+property]()+amount); + } + + if(fixOvershoot && (sum.getDate() < date.getDate())){ + sum.setDate(0); + } + + return sum; // Date +}; + +dojo.date.difference = function(/*Date*/date1, /*Date?*/date2, /*String?*/interval){ + // summary: + // Get the difference in a specific unit of time (e.g., number of + // months, weeks, days, etc.) between two dates, rounded to the + // nearest integer. + // date1: + // Date object + // date2: + // Date object. If not specified, the current Date is used. + // interval: + // A string representing the interval. One of the following: + // "year", "month", "day", "hour", "minute", "second", + // "millisecond", "quarter", "week", "weekday" + // Defaults to "day". + + date2 = date2 || new Date(); + interval = interval || "day"; + var yearDiff = date2.getFullYear() - date1.getFullYear(); + var delta = 1; // Integer return value + + switch(interval){ + case "quarter": + var m1 = date1.getMonth(); + var m2 = date2.getMonth(); + // Figure out which quarter the months are in + var q1 = Math.floor(m1/3) + 1; + var q2 = Math.floor(m2/3) + 1; + // Add quarters for any year difference between the dates + q2 += (yearDiff * 4); + delta = q2 - q1; + break; + case "weekday": + var days = Math.round(dojo.date.difference(date1, date2, "day")); + var weeks = parseInt(dojo.date.difference(date1, date2, "week")); + var mod = days % 7; + + // Even number of weeks + if(mod == 0){ + days = weeks*5; + }else{ + // Weeks plus spare change (< 7 days) + var adj = 0; + var aDay = date1.getDay(); + var bDay = date2.getDay(); + + weeks = parseInt(days/7); + mod = days % 7; + // Mark the date advanced by the number of + // round weeks (may be zero) + var dtMark = new Date(date1); + dtMark.setDate(dtMark.getDate()+(weeks*7)); + var dayMark = dtMark.getDay(); + + // Spare change days -- 6 or less + if(days > 0){ + switch(true){ + // Range starts on Sat + case aDay == 6: + adj = -1; + break; + // Range starts on Sun + case aDay == 0: + adj = 0; + break; + // Range ends on Sat + case bDay == 6: + adj = -1; + break; + // Range ends on Sun + case bDay == 0: + adj = -2; + break; + // Range contains weekend + case (dayMark + mod) > 5: + adj = -2; + } + }else if(days < 0){ + switch(true){ + // Range starts on Sat + case aDay == 6: + adj = 0; + break; + // Range starts on Sun + case aDay == 0: + adj = 1; + break; + // Range ends on Sat + case bDay == 6: + adj = 2; + break; + // Range ends on Sun + case bDay == 0: + adj = 1; + break; + // Range contains weekend + case (dayMark + mod) < 0: + adj = 2; + } + } + days += adj; + days -= (weeks*2); + } + delta = days; + break; + case "year": + delta = yearDiff; + break; + case "month": + delta = (date2.getMonth() - date1.getMonth()) + (yearDiff * 12); + break; + case "week": + // Truncate instead of rounding + // Don't use Math.floor -- value may be negative + delta = parseInt(dojo.date.difference(date1, date2, "day")/7); + break; + case "day": + delta /= 24; + // fallthrough + case "hour": + delta /= 60; + // fallthrough + case "minute": + delta /= 60; + // fallthrough + case "second": + delta /= 1000; + // fallthrough + case "millisecond": + delta *= date2.getTime() - date1.getTime(); + } + + // Round for fractional values and DST leaps + return Math.round(delta); // Number (integer) +}; + +return dojo.date; +}); -- cgit v1.2.3