mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-07 17:49:17 +00:00
New build scripts
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@5282 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Gavin Cornwell
496
source/web/scripts/ajax/dojo/src/date/common.js
Normal file
496
source/web/scripts/ajax/dojo/src/date/common.js
Normal file
@@ -0,0 +1,496 @@
|
||||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.date.common");
|
||||
|
||||
|
||||
/* Supplementary Date Functions
|
||||
*******************************/
|
||||
|
||||
dojo.date.setDayOfYear = function(/*Date*/dateObject, /*Number*/dayOfYear){
|
||||
// summary: sets dateObject according to day of the year (1..366)
|
||||
dateObject.setMonth(0);
|
||||
dateObject.setDate(dayOfYear);
|
||||
return dateObject; // Date
|
||||
}
|
||||
|
||||
dojo.date.getDayOfYear = function(/*Date*/dateObject){
|
||||
// summary: gets the day of the year as represented by dateObject
|
||||
var fullYear = dateObject.getFullYear();
|
||||
var lastDayOfPrevYear = new Date(fullYear-1, 11, 31);
|
||||
return Math.floor((dateObject.getTime() -
|
||||
lastDayOfPrevYear.getTime()) / 86400000); // Number
|
||||
}
|
||||
|
||||
|
||||
dojo.date.setWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){
|
||||
if(arguments.length == 1){ firstDay = 0; } // Sunday
|
||||
dojo.unimplemented("dojo.date.setWeekOfYear");
|
||||
}
|
||||
|
||||
dojo.date.getWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay){
|
||||
if(arguments.length == 1){ firstDay = 0; } // Sunday
|
||||
|
||||
// work out the first day of the year corresponding to the week
|
||||
var firstDayOfYear = new Date(dateObject.getFullYear(), 0, 1);
|
||||
var day = firstDayOfYear.getDay();
|
||||
firstDayOfYear.setDate(firstDayOfYear.getDate() -
|
||||
day + firstDay - (day > firstDay ? 7 : 0));
|
||||
|
||||
return Math.floor((dateObject.getTime() -
|
||||
firstDayOfYear.getTime()) / 604800000);
|
||||
}
|
||||
|
||||
dojo.date.setIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/week, /*Number*/firstDay){
|
||||
// summary: unimplemented
|
||||
if (arguments.length == 1) { firstDay = 1; } // Monday
|
||||
dojo.unimplemented("dojo.date.setIsoWeekOfYear");
|
||||
}
|
||||
|
||||
dojo.date.getIsoWeekOfYear = function(/*Date*/dateObject, /*Number*/firstDay) {
|
||||
// summary: unimplemented
|
||||
if (arguments.length == 1) { firstDay = 1; } // Monday
|
||||
dojo.unimplemented("dojo.date.getIsoWeekOfYear");
|
||||
}
|
||||
|
||||
|
||||
/* Informational Functions
|
||||
**************************/
|
||||
|
||||
//DEPRECATED: These timezone arrays will be deprecated in 0.5
|
||||
dojo.date.shortTimezones = ["IDLW", "BET", "HST", "MART", "AKST", "PST", "MST",
|
||||
"CST", "EST", "AST", "NFT", "BST", "FST", "AT", "GMT", "CET", "EET", "MSK",
|
||||
"IRT", "GST", "AFT", "AGTT", "IST", "NPT", "ALMT", "MMT", "JT", "AWST",
|
||||
"JST", "ACST", "AEST", "LHST", "VUT", "NFT", "NZT", "CHAST", "PHOT",
|
||||
"LINT"];
|
||||
dojo.date.timezoneOffsets = [-720, -660, -600, -570, -540, -480, -420, -360,
|
||||
-300, -240, -210, -180, -120, -60, 0, 60, 120, 180, 210, 240, 270, 300,
|
||||
330, 345, 360, 390, 420, 480, 540, 570, 600, 630, 660, 690, 720, 765, 780,
|
||||
840];
|
||||
/*
|
||||
dojo.date.timezones = ["International Date Line West", "Bering Standard Time",
|
||||
"Hawaiian Standard Time", "Marquesas Time", "Alaska Standard Time",
|
||||
"Pacific Standard Time (USA)", "Mountain Standard Time",
|
||||
"Central Standard Time (USA)", "Eastern Standard Time (USA)",
|
||||
"Atlantic Standard Time", "Newfoundland Time", "Brazil Standard Time",
|
||||
"Fernando de Noronha Standard Time (Brazil)", "Azores Time",
|
||||
"Greenwich Mean Time", "Central Europe Time", "Eastern Europe Time",
|
||||
"Moscow Time", "Iran Standard Time", "Gulf Standard Time",
|
||||
"Afghanistan Time", "Aqtobe Time", "Indian Standard Time", "Nepal Time",
|
||||
"Almaty Time", "Myanmar Time", "Java Time",
|
||||
"Australian Western Standard Time", "Japan Standard Time",
|
||||
"Australian Central Standard Time", "Lord Hove Standard Time (Australia)",
|
||||
"Vanuata Time", "Norfolk Time (Australia)", "New Zealand Standard Time",
|
||||
"Chatham Standard Time (New Zealand)", "Phoenix Islands Time (Kribati)",
|
||||
"Line Islands Time (Kribati)"];
|
||||
*/
|
||||
|
||||
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
|
||||
else { 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 == 0) ? true : (year%100 == 0) ? false : (year%4 == 0) ? true : false; // 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) {
|
||||
pos++;
|
||||
tz = str.substring(pos, str.indexOf(')'));
|
||||
}
|
||||
// If at first you don't succeed ...
|
||||
else{
|
||||
// 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];
|
||||
}
|
||||
// Some browsers (e.g. Safari) glue the TZ on the end
|
||||
// of toLocaleString instead of putting it in toString
|
||||
else{
|
||||
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
|
||||
}
|
||||
|
||||
|
||||
//FIXME: not localized
|
||||
dojo.date.getOrdinal = function(dateObject){
|
||||
// summary: returns the appropriate suffix (English only) for the day of the month, e.g. 'st' for 1, 'nd' for 2, etc.)
|
||||
var date = dateObject.getDate();
|
||||
|
||||
if(date%100 != 11 && date%10 == 1){ return "st"; } // String
|
||||
else if(date%100 != 12 && date%10 == 2){ return "nd"; } // String
|
||||
else if(date%100 != 13 && date%10 == 3){ return "rd"; } // String
|
||||
else{ return "th"; } // String
|
||||
}
|
||||
|
||||
|
||||
/* compare and add
|
||||
******************/
|
||||
dojo.date.compareTypes={
|
||||
// summary
|
||||
// bitmask for comparison operations.
|
||||
DATE:1, TIME:2
|
||||
};
|
||||
dojo.date.compare=function(/* Date */ dateA, /* Date */ dateB, /* dojo.date.compareTypes */ options){
|
||||
// summary
|
||||
// Compare two date objects by date, time, or both. Returns 0 if equal, positive if a > b, else negative.
|
||||
var dA=dateA;
|
||||
var dB=dateB||new Date();
|
||||
var now=new Date();
|
||||
//FIXME: shorten this code
|
||||
with(dojo.date.compareTypes){
|
||||
var opt=options||(DATE|TIME);
|
||||
var d1=new Date(
|
||||
(opt&DATE)?dA.getFullYear():now.getFullYear(),
|
||||
(opt&DATE)?dA.getMonth():now.getMonth(),
|
||||
(opt&DATE)?dA.getDate():now.getDate(),
|
||||
(opt&TIME)?dA.getHours():0,
|
||||
(opt&TIME)?dA.getMinutes():0,
|
||||
(opt&TIME)?dA.getSeconds():0
|
||||
);
|
||||
var d2=new Date(
|
||||
(opt&DATE)?dB.getFullYear():now.getFullYear(),
|
||||
(opt&DATE)?dB.getMonth():now.getMonth(),
|
||||
(opt&DATE)?dB.getDate():now.getDate(),
|
||||
(opt&TIME)?dB.getHours():0,
|
||||
(opt&TIME)?dB.getMinutes():0,
|
||||
(opt&TIME)?dB.getSeconds():0
|
||||
);
|
||||
}
|
||||
if(d1.valueOf()>d2.valueOf()){
|
||||
return 1; // int
|
||||
}
|
||||
if(d1.valueOf()<d2.valueOf()){
|
||||
return -1; // int
|
||||
}
|
||||
return 0; // int
|
||||
}
|
||||
|
||||
dojo.date.dateParts={
|
||||
// summary
|
||||
// constants for use in dojo.date.add
|
||||
YEAR:0, MONTH:1, DAY:2, HOUR:3, MINUTE:4, SECOND:5, MILLISECOND:6, QUARTER:7, WEEK:8, WEEKDAY:9
|
||||
};
|
||||
|
||||
dojo.date.add = function(/* Date */ dt, /* dojo.date.dateParts */ interv, /* int */ incr){
|
||||
// summary:
|
||||
// Add to a Date in intervals of different size, from milliseconds to years
|
||||
//
|
||||
// dt:
|
||||
// A Javascript Date object to start with
|
||||
//
|
||||
// interv:
|
||||
// A constant representing the interval, e.g. YEAR, MONTH, DAY. See dojo.date.dateParts.
|
||||
//
|
||||
// incr:
|
||||
// How much to add to the date
|
||||
|
||||
if(typeof dt == 'number'){dt = new Date(dt);} // Allow timestamps
|
||||
//FIXME: what's the reason behind this? incr = incr || 1;
|
||||
|
||||
function fixOvershoot(){
|
||||
if (sum.getDate() < dt.getDate()){
|
||||
sum.setDate(0);
|
||||
}
|
||||
}
|
||||
|
||||
var sum = new Date(dt);
|
||||
|
||||
with(dojo.date.dateParts){
|
||||
switch(interv){
|
||||
case YEAR:
|
||||
sum.setFullYear(dt.getFullYear()+incr);
|
||||
// Keep increment/decrement from 2/29 out of March
|
||||
fixOvershoot();
|
||||
break;
|
||||
case QUARTER:
|
||||
// Naive quarter is just three months
|
||||
incr*=3;
|
||||
// fallthrough...
|
||||
case MONTH:
|
||||
sum.setMonth(dt.getMonth()+incr);
|
||||
// Reset to last day of month if you overshoot
|
||||
fixOvershoot();
|
||||
break;
|
||||
case WEEK:
|
||||
incr*=7;
|
||||
// fallthrough...
|
||||
case DAY:
|
||||
sum.setDate(dt.getDate() + incr);
|
||||
break;
|
||||
case WEEKDAY:
|
||||
//FIXME: assumes Saturday/Sunday weekend, but even this is not fixed. There are CLDR entries to localize this.
|
||||
var dat = dt.getDate();
|
||||
var weeks = 0;
|
||||
var days = 0;
|
||||
var strt = 0;
|
||||
var trgt = 0;
|
||||
var adj = 0;
|
||||
// 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 mod = incr % 5;
|
||||
if (mod == 0) {
|
||||
days = (incr > 0) ? 5 : -5;
|
||||
weeks = (incr > 0) ? ((incr-5)/5) : ((incr+5)/5);
|
||||
}
|
||||
else {
|
||||
days = mod;
|
||||
weeks = parseInt(incr/5);
|
||||
}
|
||||
// Get weekday value for orig date param
|
||||
strt = dt.getDay();
|
||||
// Orig date is Sat / positive incrementer
|
||||
// Jump over Sun
|
||||
if (strt == 6 && incr > 0) {
|
||||
adj = 1;
|
||||
}
|
||||
// Orig date is Sun / negative incrementer
|
||||
// Jump back over Sat
|
||||
else if (strt == 0 && incr < 0) {
|
||||
adj = -1;
|
||||
}
|
||||
// Get weekday val for the new date
|
||||
trgt = (strt + days);
|
||||
// New date is on Sat or Sun
|
||||
if (trgt == 0 || trgt == 6) {
|
||||
adj = (incr > 0) ? 2 : -2;
|
||||
}
|
||||
// Increment by number of weeks plus leftover days plus
|
||||
// weekend adjustments
|
||||
sum.setDate(dat + (7*weeks) + days + adj);
|
||||
break;
|
||||
case HOUR:
|
||||
sum.setHours(sum.getHours()+incr);
|
||||
break;
|
||||
case MINUTE:
|
||||
sum.setMinutes(sum.getMinutes()+incr);
|
||||
break;
|
||||
case SECOND:
|
||||
sum.setSeconds(sum.getSeconds()+incr);
|
||||
break;
|
||||
case MILLISECOND:
|
||||
sum.setMilliseconds(sum.getMilliseconds()+incr);
|
||||
break;
|
||||
default:
|
||||
// Do nothing
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return sum; // Date
|
||||
};
|
||||
|
||||
dojo.date.diff = function(/* Date */ dtA, /* Date */ dtB, /* dojo.date.dateParts */ interv){
|
||||
// summary:
|
||||
// Get the difference in a specific unit of time (e.g., number of months, weeks,
|
||||
// days, etc.) between two dates.
|
||||
//
|
||||
// dtA:
|
||||
// A Javascript Date object
|
||||
//
|
||||
// dtB:
|
||||
// A Javascript Date object
|
||||
//
|
||||
// interv:
|
||||
// A constant representing the interval, e.g. YEAR, MONTH, DAY. See dojo.date.dateParts.
|
||||
|
||||
// Accept timestamp input
|
||||
if(typeof dtA == 'number'){dtA = new Date(dtA);}
|
||||
if(typeof dtB == 'number'){dtB = new Date(dtB);}
|
||||
var yeaDiff = dtB.getFullYear() - dtA.getFullYear();
|
||||
var monDiff = (dtB.getMonth() - dtA.getMonth()) + (yeaDiff * 12);
|
||||
var msDiff = dtB.getTime() - dtA.getTime(); // Millisecs
|
||||
var secDiff = msDiff/1000;
|
||||
var minDiff = secDiff/60;
|
||||
var houDiff = minDiff/60;
|
||||
var dayDiff = houDiff/24;
|
||||
var weeDiff = dayDiff/7;
|
||||
var delta = 0; // Integer return value
|
||||
|
||||
with(dojo.date.dateParts){
|
||||
switch(interv){
|
||||
case YEAR:
|
||||
delta = yeaDiff;
|
||||
break;
|
||||
case QUARTER:
|
||||
var mA = dtA.getMonth();
|
||||
var mB = dtB.getMonth();
|
||||
// Figure out which quarter the months are in
|
||||
var qA = Math.floor(mA/3) + 1;
|
||||
var qB = Math.floor(mB/3) + 1;
|
||||
// Add quarters for any year difference between the dates
|
||||
qB += (yeaDiff * 4);
|
||||
delta = qB - qA;
|
||||
break;
|
||||
case MONTH:
|
||||
delta = monDiff;
|
||||
break;
|
||||
case WEEK:
|
||||
// Truncate instead of rounding
|
||||
// Don't use Math.floor -- value may be negative
|
||||
delta = parseInt(weeDiff);
|
||||
break;
|
||||
case DAY:
|
||||
delta = dayDiff;
|
||||
break;
|
||||
case WEEKDAY:
|
||||
var days = Math.round(dayDiff);
|
||||
var weeks = parseInt(days/7);
|
||||
var mod = days % 7;
|
||||
|
||||
// Even number of weeks
|
||||
if (mod == 0) {
|
||||
days = weeks*5;
|
||||
}
|
||||
// Weeks plus spare change (< 7 days)
|
||||
else {
|
||||
var adj = 0;
|
||||
var aDay = dtA.getDay();
|
||||
var bDay = dtB.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(dtA);
|
||||
dtMark.setDate(dtMark.getDate()+(weeks*7));
|
||||
var dayMark = dtMark.getDay();
|
||||
// Spare change days -- 6 or less
|
||||
// ----------
|
||||
// Positive diff
|
||||
if (dayDiff > 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;
|
||||
break;
|
||||
default:
|
||||
// Do nothing
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Negative diff
|
||||
else if (dayDiff < 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;
|
||||
break;
|
||||
default:
|
||||
// Do nothing
|
||||
break;
|
||||
}
|
||||
}
|
||||
days += adj;
|
||||
days -= (weeks*2);
|
||||
}
|
||||
delta = days;
|
||||
|
||||
break;
|
||||
case HOUR:
|
||||
delta = houDiff;
|
||||
break;
|
||||
case MINUTE:
|
||||
delta = minDiff;
|
||||
break;
|
||||
case SECOND:
|
||||
delta = secDiff;
|
||||
break;
|
||||
case MILLISECOND:
|
||||
delta = msDiff;
|
||||
break;
|
||||
default:
|
||||
// Do nothing
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Round for fractional values and DST leaps
|
||||
return Math.round(delta); // Number (integer)
|
||||
};
|
||||
922
source/web/scripts/ajax/dojo/src/date/format.js
Normal file
922
source/web/scripts/ajax/dojo/src/date/format.js
Normal file
@@ -0,0 +1,922 @@
|
||||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.date.format");
|
||||
|
||||
dojo.require("dojo.date.common");
|
||||
dojo.require("dojo.date.supplemental");
|
||||
dojo.require("dojo.lang.array");
|
||||
dojo.require("dojo.lang.common");
|
||||
dojo.require("dojo.lang.func");
|
||||
dojo.require("dojo.string.common");
|
||||
dojo.require("dojo.i18n.common");
|
||||
|
||||
// Load the bundles containing localization information for
|
||||
// names and formats
|
||||
dojo.requireLocalization("dojo.i18n.calendar", "gregorian", null, "de,en,es,fi,fr,hu,ja,it,ko,nl,pt,sv,zh,pt-br,zh-cn,zh-hk,zh-tw,ROOT");
|
||||
dojo.requireLocalization("dojo.i18n.calendar", "gregorianExtras", null, "ja,zh,ROOT");
|
||||
|
||||
//NOTE: Everything in this module assumes Gregorian calendars.
|
||||
// Other calendars will be implemented in separate modules.
|
||||
|
||||
(function(){
|
||||
dojo.date.format = function(/*Date*/dateObject, /*Object?*/options){
|
||||
//
|
||||
// summary:
|
||||
// Format a Date object as a String, using locale-specific settings.
|
||||
//
|
||||
// description:
|
||||
// Create a string from a Date object using a known localized pattern.
|
||||
// By default, this method formats both date and time from dateObject.
|
||||
// Formatting patterns are chosen appropriate to the locale. Different
|
||||
// formatting lengths may be chosen, with "full" used by default.
|
||||
// Custom patterns may be used or registered with translations using
|
||||
// the addCustomBundle method.
|
||||
// Formatting patterns are implemented using the syntax described at
|
||||
// http://www.unicode.org/reports/tr35/tr35-4.html#Date_Format_Patterns
|
||||
//
|
||||
// dateObject:
|
||||
// the date and/or time to be formatted. If a time only is formatted,
|
||||
// the values in the year, month, and day fields are irrelevant. The
|
||||
// opposite is true when formatting only dates.
|
||||
//
|
||||
// options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string}
|
||||
// selector- choice of timeOnly,dateOnly (default: date and time)
|
||||
// formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full'
|
||||
// datePattern,timePattern- override pattern with this string
|
||||
// am,pm- override strings for am/pm in times
|
||||
// locale- override the locale used to determine formatting rules
|
||||
//
|
||||
|
||||
if(typeof options == "string"){
|
||||
dojo.deprecated("dojo.date.format", "To format dates with POSIX-style strings, please use dojo.date.strftime instead", "0.5");
|
||||
return dojo.date.strftime(dateObject, options);
|
||||
}
|
||||
|
||||
// Format a pattern without literals
|
||||
function formatPattern(dateObject, pattern){
|
||||
return pattern.replace(/([a-z])\1*/ig, function(match){
|
||||
var s;
|
||||
var c = match.charAt(0);
|
||||
var l = match.length;
|
||||
var pad;
|
||||
var widthList = ["abbr", "wide", "narrow"];
|
||||
switch(c){
|
||||
case 'G':
|
||||
if(l>3){dojo.unimplemented("Era format not implemented");}
|
||||
s = info.eras[dateObject.getFullYear() < 0 ? 1 : 0];
|
||||
break;
|
||||
case 'y':
|
||||
s = dateObject.getFullYear();
|
||||
switch(l){
|
||||
case 1:
|
||||
break;
|
||||
case 2:
|
||||
s = String(s).substr(-2);
|
||||
break;
|
||||
default:
|
||||
pad = true;
|
||||
}
|
||||
break;
|
||||
case 'Q':
|
||||
case 'q':
|
||||
s = Math.ceil((dateObject.getMonth()+1)/3);
|
||||
switch(l){
|
||||
case 1: case 2:
|
||||
pad = true;
|
||||
break;
|
||||
case 3:
|
||||
case 4:
|
||||
dojo.unimplemented("Quarter format not implemented");
|
||||
}
|
||||
break;
|
||||
case 'M':
|
||||
case 'L':
|
||||
var m = dateObject.getMonth();
|
||||
var width;
|
||||
switch(l){
|
||||
case 1: case 2:
|
||||
s = m+1; pad = true;
|
||||
break;
|
||||
case 3: case 4: case 5:
|
||||
width = widthList[l-3];
|
||||
break;
|
||||
}
|
||||
if(width){
|
||||
var type = (c == "L") ? "standalone" : "format";
|
||||
var prop = ["months",type,width].join("-");
|
||||
s = info[prop][m];
|
||||
}
|
||||
break;
|
||||
case 'w':
|
||||
var firstDay = 0;
|
||||
s = dojo.date.getWeekOfYear(dateObject, firstDay); pad = true;
|
||||
break;
|
||||
case 'd':
|
||||
s = dateObject.getDate(); pad = true;
|
||||
break;
|
||||
case 'D':
|
||||
s = dojo.date.getDayOfYear(dateObject); pad = true;
|
||||
break;
|
||||
case 'E':
|
||||
case 'e':
|
||||
case 'c': // REVIEW: don't see this in the spec?
|
||||
var d = dateObject.getDay();
|
||||
var width;
|
||||
switch(l){
|
||||
case 1: case 2:
|
||||
if(c == 'e'){
|
||||
var first = dojo.date.getFirstDayOfWeek(options.locale);
|
||||
d = (d-first+7)%7;
|
||||
}
|
||||
if(c != 'c'){
|
||||
s = d+1; pad = true;
|
||||
break;
|
||||
}
|
||||
// else fallthrough...
|
||||
case 3: case 4: case 5:
|
||||
width = widthList[l-3];
|
||||
break;
|
||||
}
|
||||
if(width){
|
||||
var type = (c == "c") ? "standalone" : "format";
|
||||
var prop = ["days",type,width].join("-");
|
||||
s = info[prop][d];
|
||||
}
|
||||
break;
|
||||
case 'a':
|
||||
var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
|
||||
s = info[timePeriod];
|
||||
break;
|
||||
case 'h':
|
||||
case 'H':
|
||||
case 'K':
|
||||
case 'k':
|
||||
var h = dateObject.getHours();
|
||||
// strange choices in the date format make it impossible to write this succinctly
|
||||
switch (c) {
|
||||
case 'h': // 1-12
|
||||
s = (h % 12) || 12;
|
||||
break;
|
||||
case 'H': // 0-23
|
||||
s = h;
|
||||
break;
|
||||
case 'K': // 0-11
|
||||
s = (h % 12);
|
||||
break;
|
||||
case 'k': // 1-24
|
||||
s = h || 24;
|
||||
break;
|
||||
}
|
||||
pad = true;
|
||||
break;
|
||||
case 'm':
|
||||
s = dateObject.getMinutes(); pad = true;
|
||||
break;
|
||||
case 's':
|
||||
s = dateObject.getSeconds(); pad = true;
|
||||
break;
|
||||
case 'S':
|
||||
s = Math.round(dateObject.getMilliseconds() * Math.pow(10, l-3));
|
||||
break;
|
||||
case 'v': // FIXME: don't know what this is. seems to be same as z?
|
||||
case 'z':
|
||||
// We only have one timezone to offer; the one from the browser
|
||||
s = dojo.date.getTimezoneName(dateObject);
|
||||
if(s){break;}
|
||||
l=4;
|
||||
// fallthrough... use GMT if tz not available
|
||||
case 'Z':
|
||||
var offset = dateObject.getTimezoneOffset();
|
||||
var tz = [
|
||||
(offset<=0 ? "+" : "-"),
|
||||
dojo.string.pad(Math.floor(Math.abs(offset)/60), 2),
|
||||
dojo.string.pad(Math.abs(offset)% 60, 2)
|
||||
];
|
||||
if(l==4){
|
||||
tz.splice(0, 0, "GMT");
|
||||
tz.splice(3, 0, ":");
|
||||
}
|
||||
s = tz.join("");
|
||||
break;
|
||||
case 'Y':
|
||||
case 'u':
|
||||
case 'W':
|
||||
case 'F':
|
||||
case 'g':
|
||||
case 'A':
|
||||
dojo.debug(match+" modifier not yet implemented");
|
||||
s = "?";
|
||||
break;
|
||||
default:
|
||||
dojo.raise("dojo.date.format: invalid pattern char: "+pattern);
|
||||
}
|
||||
if(pad){ s = dojo.string.pad(s, l); }
|
||||
return s;
|
||||
});
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
|
||||
var locale = dojo.hostenv.normalizeLocale(options.locale);
|
||||
var formatLength = options.formatLength || 'full';
|
||||
var info = dojo.date._getGregorianBundle(locale);
|
||||
var str = [];
|
||||
var sauce = dojo.lang.curry(this, formatPattern, dateObject);
|
||||
if(options.selector != "timeOnly"){
|
||||
var datePattern = options.datePattern || info["dateFormat-"+formatLength];
|
||||
if(datePattern){str.push(_processPattern(datePattern, sauce));}
|
||||
}
|
||||
if(options.selector != "dateOnly"){
|
||||
var timePattern = options.timePattern || info["timeFormat-"+formatLength];
|
||||
if(timePattern){str.push(_processPattern(timePattern, sauce));}
|
||||
}
|
||||
var result = str.join(" "); //TODO: use locale-specific pattern to assemble date + time
|
||||
return result; /*String*/
|
||||
};
|
||||
|
||||
dojo.date.parse = function(/*String*/value, /*Object?*/options){
|
||||
//
|
||||
// summary:
|
||||
// Convert a properly formatted string to a primitive Date object,
|
||||
// using locale-specific settings.
|
||||
//
|
||||
// description:
|
||||
// Create a Date object from a string using a known localized pattern.
|
||||
// By default, this method parses looking for both date and time in the string.
|
||||
// Formatting patterns are chosen appropriate to the locale. Different
|
||||
// formatting lengths may be chosen, with "full" used by default.
|
||||
// Custom patterns may be used or registered with translations using
|
||||
// the addCustomBundle method.
|
||||
// Formatting patterns are implemented using the syntax described at
|
||||
// http://www.unicode.org/reports/tr35/#Date_Format_Patterns
|
||||
//
|
||||
// value:
|
||||
// A string representation of a date
|
||||
//
|
||||
// options: object {selector: string, formatLength: string, datePattern: string, timePattern: string, locale: string, strict: boolean}
|
||||
// selector- choice of timeOnly, dateOnly, dateTime (default: dateOnly)
|
||||
// formatLength- choice of long, short, medium or full (plus any custom additions). Defaults to 'full'
|
||||
// datePattern,timePattern- override pattern with this string
|
||||
// am,pm- override strings for am/pm in times
|
||||
// locale- override the locale used to determine formatting rules
|
||||
// strict- strict parsing, off by default
|
||||
//
|
||||
|
||||
options = options || {};
|
||||
var locale = dojo.hostenv.normalizeLocale(options.locale);
|
||||
var info = dojo.date._getGregorianBundle(locale);
|
||||
var formatLength = options.formatLength || 'full';
|
||||
if(!options.selector){ options.selector = 'dateOnly'; }
|
||||
var datePattern = options.datePattern || info["dateFormat-" + formatLength];
|
||||
var timePattern = options.timePattern || info["timeFormat-" + formatLength];
|
||||
|
||||
var pattern;
|
||||
if(options.selector == 'dateOnly'){
|
||||
pattern = datePattern;
|
||||
}
|
||||
else if(options.selector == 'timeOnly'){
|
||||
pattern = timePattern;
|
||||
}else if(options.selector == 'dateTime'){
|
||||
pattern = datePattern + ' ' + timePattern; //TODO: use locale-specific pattern to assemble date + time
|
||||
}else{
|
||||
var msg = "dojo.date.parse: Unknown selector param passed: '" + options.selector + "'.";
|
||||
msg += " Defaulting to date pattern.";
|
||||
dojo.debug(msg);
|
||||
pattern = datePattern;
|
||||
}
|
||||
|
||||
var groups = [];
|
||||
var dateREString = _processPattern(pattern, dojo.lang.curry(this, _buildDateTimeRE, groups, info, options));
|
||||
var dateRE = new RegExp("^" + dateREString + "$");
|
||||
|
||||
var match = dateRE.exec(value);
|
||||
if(!match){
|
||||
return null;
|
||||
}
|
||||
|
||||
var widthList = ['abbr', 'wide', 'narrow'];
|
||||
//1972 is a leap year. We want to avoid Feb 29 rolling over into Mar 1,
|
||||
//in the cases where the year is parsed after the month and day.
|
||||
var result = new Date(1972, 0);
|
||||
var expected = {};
|
||||
for(var i=1; i<match.length; i++){
|
||||
var grp=groups[i-1];
|
||||
var l=grp.length;
|
||||
var v=match[i];
|
||||
switch(grp.charAt(0)){
|
||||
case 'y':
|
||||
if(l != 2){
|
||||
//interpret year literally, so '5' would be 5 A.D.
|
||||
result.setFullYear(v);
|
||||
expected.year = v;
|
||||
}else{
|
||||
if(v<100){
|
||||
v = Number(v);
|
||||
//choose century to apply, according to a sliding window
|
||||
//of 80 years before and 20 years after present year
|
||||
var year = '' + new Date().getFullYear();
|
||||
var century = year.substring(0, 2) * 100;
|
||||
var yearPart = Number(year.substring(2, 4));
|
||||
var cutoff = Math.min(yearPart + 20, 99);
|
||||
var num = (v < cutoff) ? century + v : century - 100 + v;
|
||||
result.setFullYear(num);
|
||||
expected.year = num;
|
||||
}else{
|
||||
//we expected 2 digits and got more...
|
||||
if(options.strict){
|
||||
return null;
|
||||
}
|
||||
//interpret literally, so '150' would be 150 A.D.
|
||||
//also tolerate '1950', if 'yyyy' input passed to 'yy' format
|
||||
result.setFullYear(v);
|
||||
expected.year = v;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 'M':
|
||||
if (l>2) {
|
||||
if(!options.strict){
|
||||
//Tolerate abbreviating period in month part
|
||||
v = v.replace(/\./g,'');
|
||||
//Case-insensitive
|
||||
v = v.toLowerCase();
|
||||
}
|
||||
var months = info['months-format-' + widthList[l-3]].concat();
|
||||
for (var j=0; j<months.length; j++){
|
||||
if(!options.strict){
|
||||
//Case-insensitive
|
||||
months[j] = months[j].toLowerCase();
|
||||
}
|
||||
if(v == months[j]){
|
||||
result.setMonth(j);
|
||||
expected.month = j;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(j==months.length){
|
||||
dojo.debug("dojo.date.parse: Could not parse month name: '" + v + "'.");
|
||||
return null;
|
||||
}
|
||||
}else{
|
||||
result.setMonth(v-1);
|
||||
expected.month = v-1;
|
||||
}
|
||||
break;
|
||||
case 'E':
|
||||
case 'e':
|
||||
if(!options.strict){
|
||||
//Case-insensitive
|
||||
v = v.toLowerCase();
|
||||
}
|
||||
var days = info['days-format-' + widthList[l-3]].concat();
|
||||
for (var j=0; j<days.length; j++){
|
||||
if(!options.strict){
|
||||
//Case-insensitive
|
||||
days[j] = days[j].toLowerCase();
|
||||
}
|
||||
if(v == days[j]){
|
||||
//TODO: not sure what to actually do with this input,
|
||||
//in terms of setting something on the Date obj...?
|
||||
//without more context, can't affect the actual date
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(j==days.length){
|
||||
dojo.debug("dojo.date.parse: Could not parse weekday name: '" + v + "'.");
|
||||
return null;
|
||||
}
|
||||
break;
|
||||
case 'd':
|
||||
result.setDate(v);
|
||||
expected.date = v;
|
||||
break;
|
||||
case 'a': //am/pm
|
||||
var am = options.am || info.am;
|
||||
var pm = options.pm || info.pm;
|
||||
if(!options.strict){
|
||||
v = v.replace(/\./g,'').toLowerCase();
|
||||
am = am.replace(/\./g,'').toLowerCase();
|
||||
pm = pm.replace(/\./g,'').toLowerCase();
|
||||
}
|
||||
if(options.strict && v != am && v != pm){
|
||||
dojo.debug("dojo.date.parse: Could not parse am/pm part.");
|
||||
return null;
|
||||
}
|
||||
var hours = result.getHours();
|
||||
if(v == pm && hours < 12){
|
||||
result.setHours(hours + 12); //e.g., 3pm -> 15
|
||||
} else if(v == am && hours == 12){
|
||||
result.setHours(0); //12am -> 0
|
||||
}
|
||||
break;
|
||||
case 'K': //hour (1-24)
|
||||
if(v==24){v=0;}
|
||||
// fallthrough...
|
||||
case 'h': //hour (1-12)
|
||||
case 'H': //hour (0-23)
|
||||
case 'k': //hour (0-11)
|
||||
//TODO: strict bounds checking, padding
|
||||
if(v>23){
|
||||
dojo.debug("dojo.date.parse: Illegal hours value");
|
||||
return null;
|
||||
}
|
||||
|
||||
//in the 12-hour case, adjusting for am/pm requires the 'a' part
|
||||
//which for now we will assume always comes after the 'h' part
|
||||
result.setHours(v);
|
||||
break;
|
||||
case 'm': //minutes
|
||||
result.setMinutes(v);
|
||||
break;
|
||||
case 's': //seconds
|
||||
result.setSeconds(v);
|
||||
break;
|
||||
case 'S': //milliseconds
|
||||
result.setMilliseconds(v);
|
||||
break;
|
||||
default:
|
||||
dojo.unimplemented("dojo.date.parse: unsupported pattern char=" + grp.charAt(0));
|
||||
}
|
||||
}
|
||||
|
||||
//validate parse date fields versus input date fields
|
||||
if(expected.year && result.getFullYear() != expected.year){
|
||||
dojo.debug("Parsed year: '" + result.getFullYear() + "' did not match input year: '" + expected.year + "'.");
|
||||
return null;
|
||||
}
|
||||
if(expected.month && result.getMonth() != expected.month){
|
||||
dojo.debug("Parsed month: '" + result.getMonth() + "' did not match input month: '" + expected.month + "'.");
|
||||
return null;
|
||||
}
|
||||
if(expected.date && result.getDate() != expected.date){
|
||||
dojo.debug("Parsed day of month: '" + result.getDate() + "' did not match input day of month: '" + expected.date + "'.");
|
||||
return null;
|
||||
}
|
||||
|
||||
//TODO: implement a getWeekday() method in order to test
|
||||
//validity of input strings containing 'EEE' or 'EEEE'...
|
||||
|
||||
return result; /*Date*/
|
||||
};
|
||||
|
||||
function _processPattern(pattern, applyPattern, applyLiteral, applyAll){
|
||||
// Process a pattern with literals in it
|
||||
// Break up on single quotes, treat every other one as a literal, except '' which becomes '
|
||||
var identity = function(x){return x;};
|
||||
applyPattern = applyPattern || identity;
|
||||
applyLiteral = applyLiteral || identity;
|
||||
applyAll = applyAll || identity;
|
||||
|
||||
//split on single quotes (which escape literals in date format strings)
|
||||
//but preserve escaped single quotes (e.g., o''clock)
|
||||
var chunks = pattern.match(/(''|[^'])+/g);
|
||||
var literal = false;
|
||||
|
||||
for(var i=0; i<chunks.length; i++){
|
||||
if(!chunks[i]){
|
||||
chunks[i]='';
|
||||
} else {
|
||||
chunks[i]=(literal ? applyLiteral : applyPattern)(chunks[i]);
|
||||
literal = !literal;
|
||||
}
|
||||
}
|
||||
return applyAll(chunks.join(''));
|
||||
}
|
||||
|
||||
function _buildDateTimeRE(groups, info, options, pattern){
|
||||
return pattern.replace(/([a-z])\1*/ig, function(match){
|
||||
// Build a simple regexp without parenthesis, which would ruin the match list
|
||||
var s;
|
||||
var c = match.charAt(0);
|
||||
var l = match.length;
|
||||
switch(c){
|
||||
case 'y':
|
||||
s = '\\d' + ((l==2) ? '{2,4}' : '+');
|
||||
break;
|
||||
case 'M':
|
||||
s = (l>2) ? '\\S+' : '\\d{1,2}';
|
||||
break;
|
||||
case 'd':
|
||||
s = '\\d{1,2}';
|
||||
break;
|
||||
case 'E':
|
||||
s = '\\S+';
|
||||
break;
|
||||
case 'h':
|
||||
case 'H':
|
||||
case 'K':
|
||||
case 'k':
|
||||
s = '\\d{1,2}';
|
||||
break;
|
||||
case 'm':
|
||||
case 's':
|
||||
s = '[0-5]\\d';
|
||||
break;
|
||||
case 'S':
|
||||
s = '\\d{1,3}';
|
||||
break;
|
||||
case 'a':
|
||||
var am = options.am || info.am || 'AM';
|
||||
var pm = options.pm || info.pm || 'PM';
|
||||
if(options.strict){
|
||||
s = am + '|' + pm;
|
||||
}else{
|
||||
s = am;
|
||||
s += (am != am.toLowerCase()) ? '|' + am.toLowerCase() : '';
|
||||
s += '|';
|
||||
s += (pm != pm.toLowerCase()) ? pm + '|' + pm.toLowerCase() : pm;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
dojo.unimplemented("parse of date format, pattern=" + pattern);
|
||||
}
|
||||
|
||||
if(groups){ groups.push(match); }
|
||||
|
||||
//FIXME: replace whitespace within final regexp with more flexible whitespace match instead?
|
||||
//tolerate whitespace
|
||||
return '\\s*(' + s + ')\\s*';
|
||||
});
|
||||
}
|
||||
})();
|
||||
|
||||
//TODO: try to common strftime and format code somehow?
|
||||
|
||||
dojo.date.strftime = function(/*Date*/dateObject, /*String*/format, /*String?*/locale){
|
||||
//
|
||||
// summary:
|
||||
// Formats the date object using the specifications of the POSIX strftime function
|
||||
//
|
||||
// description:
|
||||
// see <http://www.opengroup.org/onlinepubs/007908799/xsh/strftime.html>
|
||||
|
||||
// zero pad
|
||||
var padChar = null;
|
||||
function _(s, n){
|
||||
return dojo.string.pad(s, n || 2, padChar || "0");
|
||||
}
|
||||
|
||||
var info = dojo.date._getGregorianBundle(locale);
|
||||
|
||||
function $(property){
|
||||
switch (property){
|
||||
case "a": // abbreviated weekday name according to the current locale
|
||||
return dojo.date.getDayShortName(dateObject, locale);
|
||||
|
||||
case "A": // full weekday name according to the current locale
|
||||
return dojo.date.getDayName(dateObject, locale);
|
||||
|
||||
case "b":
|
||||
case "h": // abbreviated month name according to the current locale
|
||||
return dojo.date.getMonthShortName(dateObject, locale);
|
||||
|
||||
case "B": // full month name according to the current locale
|
||||
return dojo.date.getMonthName(dateObject, locale);
|
||||
|
||||
case "c": // preferred date and time representation for the current
|
||||
// locale
|
||||
return dojo.date.format(dateObject, {locale: locale});
|
||||
|
||||
case "C": // century number (the year divided by 100 and truncated
|
||||
// to an integer, range 00 to 99)
|
||||
return _(Math.floor(dateObject.getFullYear()/100));
|
||||
|
||||
case "d": // day of the month as a decimal number (range 01 to 31)
|
||||
return _(dateObject.getDate());
|
||||
|
||||
case "D": // same as %m/%d/%y
|
||||
return $("m") + "/" + $("d") + "/" + $("y");
|
||||
|
||||
case "e": // day of the month as a decimal number, a single digit is
|
||||
// preceded by a space (range ' 1' to '31')
|
||||
if(padChar == null){ padChar = " "; }
|
||||
return _(dateObject.getDate());
|
||||
|
||||
case "f": // month as a decimal number, a single digit is
|
||||
// preceded by a space (range ' 1' to '12')
|
||||
if(padChar == null){ padChar = " "; }
|
||||
return _(dateObject.getMonth()+1);
|
||||
|
||||
case "g": // like %G, but without the century.
|
||||
break;
|
||||
|
||||
case "G": // The 4-digit year corresponding to the ISO week number
|
||||
// (see %V). This has the same format and value as %Y,
|
||||
// except that if the ISO week number belongs to the
|
||||
// previous or next year, that year is used instead.
|
||||
dojo.unimplemented("unimplemented modifier 'G'");
|
||||
break;
|
||||
|
||||
case "F": // same as %Y-%m-%d
|
||||
return $("Y") + "-" + $("m") + "-" + $("d");
|
||||
|
||||
case "H": // hour as a decimal number using a 24-hour clock (range
|
||||
// 00 to 23)
|
||||
return _(dateObject.getHours());
|
||||
|
||||
case "I": // hour as a decimal number using a 12-hour clock (range
|
||||
// 01 to 12)
|
||||
return _(dateObject.getHours() % 12 || 12);
|
||||
|
||||
case "j": // day of the year as a decimal number (range 001 to 366)
|
||||
return _(dojo.date.getDayOfYear(dateObject), 3);
|
||||
|
||||
case "k": // Hour as a decimal number using a 24-hour clock (range
|
||||
// 0 to 23 (space-padded))
|
||||
if (padChar == null) { padChar = " "; }
|
||||
return _(dateObject.getHours());
|
||||
|
||||
case "l": // Hour as a decimal number using a 12-hour clock (range
|
||||
// 1 to 12 (space-padded))
|
||||
if (padChar == null) { padChar = " "; }
|
||||
return _(dateObject.getHours() % 12 || 12);
|
||||
|
||||
case "m": // month as a decimal number (range 01 to 12)
|
||||
return _(dateObject.getMonth() + 1);
|
||||
|
||||
case "M": // minute as a decimal number
|
||||
return _(dateObject.getMinutes());
|
||||
|
||||
case "n":
|
||||
return "\n";
|
||||
|
||||
case "p": // either `am' or `pm' according to the given time value,
|
||||
// or the corresponding strings for the current locale
|
||||
return info[dateObject.getHours() < 12 ? "am" : "pm"];
|
||||
|
||||
case "r": // time in a.m. and p.m. notation
|
||||
return $("I") + ":" + $("M") + ":" + $("S") + " " + $("p");
|
||||
|
||||
case "R": // time in 24 hour notation
|
||||
return $("H") + ":" + $("M");
|
||||
|
||||
case "S": // second as a decimal number
|
||||
return _(dateObject.getSeconds());
|
||||
|
||||
case "t":
|
||||
return "\t";
|
||||
|
||||
case "T": // current time, equal to %H:%M:%S
|
||||
return $("H") + ":" + $("M") + ":" + $("S");
|
||||
|
||||
case "u": // weekday as a decimal number [1,7], with 1 representing
|
||||
// Monday
|
||||
return String(dateObject.getDay() || 7);
|
||||
|
||||
case "U": // week number of the current year as a decimal number,
|
||||
// starting with the first Sunday as the first day of the
|
||||
// first week
|
||||
return _(dojo.date.getWeekOfYear(dateObject));
|
||||
|
||||
case "V": // week number of the year (Monday as the first day of the
|
||||
// week) as a decimal number [01,53]. If the week containing
|
||||
// 1 January has four or more days in the new year, then it
|
||||
// is considered week 1. Otherwise, it is the last week of
|
||||
// the previous year, and the next week is week 1.
|
||||
return _(dojo.date.getIsoWeekOfYear(dateObject));
|
||||
|
||||
case "W": // week number of the current year as a decimal number,
|
||||
// starting with the first Monday as the first day of the
|
||||
// first week
|
||||
return _(dojo.date.getWeekOfYear(dateObject, 1));
|
||||
|
||||
case "w": // day of the week as a decimal, Sunday being 0
|
||||
return String(dateObject.getDay());
|
||||
|
||||
case "x": // preferred date representation for the current locale
|
||||
// without the time
|
||||
return dojo.date.format(dateObject, {selector:'dateOnly', locale:locale});
|
||||
|
||||
case "X": // preferred time representation for the current locale
|
||||
// without the date
|
||||
return dojo.date.format(dateObject, {selector:'timeOnly', locale:locale});
|
||||
|
||||
case "y": // year as a decimal number without a century (range 00 to
|
||||
// 99)
|
||||
return _(dateObject.getFullYear()%100);
|
||||
|
||||
case "Y": // year as a decimal number including the century
|
||||
return String(dateObject.getFullYear());
|
||||
|
||||
case "z": // time zone or name or abbreviation
|
||||
var timezoneOffset = dateObject.getTimezoneOffset();
|
||||
return (timezoneOffset > 0 ? "-" : "+") +
|
||||
_(Math.floor(Math.abs(timezoneOffset)/60)) + ":" +
|
||||
_(Math.abs(timezoneOffset)%60);
|
||||
|
||||
case "Z": // time zone or name or abbreviation
|
||||
return dojo.date.getTimezoneName(dateObject);
|
||||
|
||||
case "%":
|
||||
return "%";
|
||||
}
|
||||
}
|
||||
|
||||
// parse the formatting string and construct the resulting string
|
||||
var string = "";
|
||||
var i = 0;
|
||||
var index = 0;
|
||||
var switchCase = null;
|
||||
while ((index = format.indexOf("%", i)) != -1){
|
||||
string += format.substring(i, index++);
|
||||
|
||||
// inspect modifier flag
|
||||
switch (format.charAt(index++)) {
|
||||
case "_": // Pad a numeric result string with spaces.
|
||||
padChar = " "; break;
|
||||
case "-": // Do not pad a numeric result string.
|
||||
padChar = ""; break;
|
||||
case "0": // Pad a numeric result string with zeros.
|
||||
padChar = "0"; break;
|
||||
case "^": // Convert characters in result string to uppercase.
|
||||
switchCase = "upper"; break;
|
||||
case "*": // Convert characters in result string to lowercase
|
||||
switchCase = "lower"; break;
|
||||
case "#": // Swap the case of the result string.
|
||||
switchCase = "swap"; break;
|
||||
default: // no modifier flag so decrement the index
|
||||
padChar = null; index--; break;
|
||||
}
|
||||
|
||||
// toggle case if a flag is set
|
||||
var property = $(format.charAt(index++));
|
||||
switch (switchCase){
|
||||
case "upper":
|
||||
property = property.toUpperCase();
|
||||
break;
|
||||
case "lower":
|
||||
property = property.toLowerCase();
|
||||
break;
|
||||
case "swap": // Upper to lower, and versey-vicea
|
||||
var compareString = property.toLowerCase();
|
||||
var swapString = '';
|
||||
var j = 0;
|
||||
var ch = '';
|
||||
while (j < property.length){
|
||||
ch = property.charAt(j);
|
||||
swapString += (ch == compareString.charAt(j)) ?
|
||||
ch.toUpperCase() : ch.toLowerCase();
|
||||
j++;
|
||||
}
|
||||
property = swapString;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
switchCase = null;
|
||||
|
||||
string += property;
|
||||
i = index;
|
||||
}
|
||||
string += format.substring(i);
|
||||
|
||||
return string; // String
|
||||
};
|
||||
|
||||
(function(){
|
||||
var _customFormats = [];
|
||||
dojo.date.addCustomFormats = function(/*String*/packageName, /*String*/bundleName){
|
||||
//
|
||||
// summary:
|
||||
// Add a reference to a bundle containing localized custom formats to be
|
||||
// used by date/time formatting and parsing routines.
|
||||
//
|
||||
// description:
|
||||
// The user may add custom localized formats where the bundle has properties following the
|
||||
// same naming convention used by dojo for the CLDR data: dateFormat-xxxx / timeFormat-xxxx
|
||||
// The pattern string should match the format used by the CLDR.
|
||||
// See dojo.date.format for details.
|
||||
// The resources must be loaded by dojo.requireLocalization() prior to use
|
||||
|
||||
_customFormats.push({pkg:packageName,name:bundleName});
|
||||
};
|
||||
|
||||
dojo.date._getGregorianBundle = function(/*String*/locale){
|
||||
var gregorian = {};
|
||||
dojo.lang.forEach(_customFormats, function(desc){
|
||||
var bundle = dojo.i18n.getLocalization(desc.pkg, desc.name, locale);
|
||||
gregorian = dojo.lang.mixin(gregorian, bundle);
|
||||
}, this);
|
||||
return gregorian; /*Object*/
|
||||
};
|
||||
})();
|
||||
|
||||
dojo.date.addCustomFormats("dojo.i18n.calendar","gregorian");
|
||||
dojo.date.addCustomFormats("dojo.i18n.calendar","gregorianExtras");
|
||||
|
||||
dojo.date.getNames = function(/*String*/item, /*String*/type, /*String?*/use, /*String?*/locale){
|
||||
//
|
||||
// summary:
|
||||
// Used to get localized strings for day or month names.
|
||||
//
|
||||
// item: 'months' || 'days'
|
||||
// type: 'wide' || 'narrow' || 'abbr' (e.g. "Monday", "Mon", or "M" respectively, in English)
|
||||
// use: 'standAlone' || 'format' (default)
|
||||
// locale: override locale used to find the names
|
||||
|
||||
var label;
|
||||
var lookup = dojo.date._getGregorianBundle(locale);
|
||||
var props = [item, use, type];
|
||||
if(use == 'standAlone'){
|
||||
label = lookup[props.join('-')];
|
||||
}
|
||||
props[1] = 'format';
|
||||
|
||||
// return by copy so changes won't be made accidentally to the in-memory model
|
||||
return (label || lookup[props.join('-')]).concat(); /*Array*/
|
||||
};
|
||||
|
||||
// Convenience methods
|
||||
|
||||
dojo.date.getDayName = function(/*Date*/dateObject, /*String?*/locale){
|
||||
// summary: gets the full localized day of the week corresponding to the date object
|
||||
return dojo.date.getNames('days', 'wide', 'format', locale)[dateObject.getDay()]; /*String*/
|
||||
};
|
||||
|
||||
dojo.date.getDayShortName = function(/*Date*/dateObject, /*String?*/locale){
|
||||
// summary: gets the abbreviated localized day of the week corresponding to the date object
|
||||
return dojo.date.getNames('days', 'abbr', 'format', locale)[dateObject.getDay()]; /*String*/
|
||||
};
|
||||
|
||||
dojo.date.getMonthName = function(/*Date*/dateObject, /*String?*/locale){
|
||||
// summary: gets the full localized month name corresponding to the date object
|
||||
return dojo.date.getNames('months', 'wide', 'format', locale)[dateObject.getMonth()]; /*String*/
|
||||
};
|
||||
|
||||
dojo.date.getMonthShortName = function(/*Date*/dateObject, /*String?*/locale){
|
||||
// summary: gets the abbreviated localized month name corresponding to the date object
|
||||
return dojo.date.getNames('months', 'abbr', 'format', locale)[dateObject.getMonth()]; /*String*/
|
||||
};
|
||||
|
||||
//FIXME: not localized
|
||||
dojo.date.toRelativeString = function(/*Date*/dateObject){
|
||||
// summary:
|
||||
// Returns an description in English of the date relative to the current date. Note: this is not localized yet. English only.
|
||||
//
|
||||
// description: Example returns:
|
||||
// - "1 minute ago"
|
||||
// - "4 minutes ago"
|
||||
// - "Yesterday"
|
||||
// - "2 days ago"
|
||||
|
||||
var now = new Date();
|
||||
var diff = (now - dateObject) / 1000;
|
||||
var end = " ago";
|
||||
var future = false;
|
||||
if(diff < 0){
|
||||
future = true;
|
||||
end = " from now";
|
||||
diff = -diff;
|
||||
}
|
||||
|
||||
if(diff < 60){
|
||||
diff = Math.round(diff);
|
||||
return diff + " second" + (diff == 1 ? "" : "s") + end;
|
||||
}
|
||||
if(diff < 60*60){
|
||||
diff = Math.round(diff/60);
|
||||
return diff + " minute" + (diff == 1 ? "" : "s") + end;
|
||||
}
|
||||
if(diff < 60*60*24){
|
||||
diff = Math.round(diff/3600);
|
||||
return diff + " hour" + (diff == 1 ? "" : "s") + end;
|
||||
}
|
||||
if(diff < 60*60*24*7){
|
||||
diff = Math.round(diff/(3600*24));
|
||||
if(diff == 1){
|
||||
return future ? "Tomorrow" : "Yesterday";
|
||||
}else{
|
||||
return diff + " days" + end;
|
||||
}
|
||||
}
|
||||
return dojo.date.format(dateObject); // String
|
||||
};
|
||||
|
||||
//FIXME: SQL methods can probably be moved to a different module without i18n deps
|
||||
|
||||
dojo.date.toSql = function(/*Date*/dateObject, /*Boolean?*/noTime){
|
||||
// summary:
|
||||
// Convert a Date to a SQL string
|
||||
// noTime: whether to ignore the time portion of the Date. Defaults to false.
|
||||
|
||||
return dojo.date.strftime(dateObject, "%F" + !noTime ? " %T" : ""); // String
|
||||
};
|
||||
|
||||
dojo.date.fromSql = function(/*String*/sqlDate){
|
||||
// summary:
|
||||
// Convert a SQL date string to a JavaScript Date object
|
||||
|
||||
var parts = sqlDate.split(/[\- :]/g);
|
||||
while(parts.length < 6){
|
||||
parts.push(0);
|
||||
}
|
||||
return new Date(parts[0], (parseInt(parts[1],10)-1), parts[2], parts[3], parts[4], parts[5]); // Date
|
||||
};
|
||||
175
source/web/scripts/ajax/dojo/src/date/serialize.js
Normal file
175
source/web/scripts/ajax/dojo/src/date/serialize.js
Normal file
@@ -0,0 +1,175 @@
|
||||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.date.serialize");
|
||||
|
||||
dojo.require("dojo.string.common");
|
||||
|
||||
/* ISO 8601 Functions
|
||||
*********************/
|
||||
|
||||
dojo.date.setIso8601 = function(/*Date*/dateObject, /*String*/formattedString){
|
||||
// summary: sets a Date object based on an ISO 8601 formatted string (uses date and time)
|
||||
var comps = (formattedString.indexOf("T") == -1) ? formattedString.split(" ") : formattedString.split("T");
|
||||
dateObject = dojo.date.setIso8601Date(dateObject, comps[0]);
|
||||
if(comps.length == 2){ dateObject = dojo.date.setIso8601Time(dateObject, comps[1]); }
|
||||
return dateObject; /* Date or null */
|
||||
};
|
||||
|
||||
dojo.date.fromIso8601 = function(/*String*/formattedString){
|
||||
// summary: returns a Date object based on an ISO 8601 formatted string (uses date and time)
|
||||
return dojo.date.setIso8601(new Date(0, 0), formattedString);
|
||||
};
|
||||
|
||||
dojo.date.setIso8601Date = function(/*String*/dateObject, /*String*/formattedString){
|
||||
// summary: sets a Date object based on an ISO 8601 formatted string (date only)
|
||||
var regexp = "^([0-9]{4})((-?([0-9]{2})(-?([0-9]{2}))?)|" +
|
||||
"(-?([0-9]{3}))|(-?W([0-9]{2})(-?([1-7]))?))?$";
|
||||
var d = formattedString.match(new RegExp(regexp));
|
||||
if(!d){
|
||||
dojo.debug("invalid date string: " + formattedString);
|
||||
return null; // null
|
||||
}
|
||||
var year = d[1];
|
||||
var month = d[4];
|
||||
var date = d[6];
|
||||
var dayofyear = d[8];
|
||||
var week = d[10];
|
||||
var dayofweek = d[12] ? d[12] : 1;
|
||||
|
||||
dateObject.setFullYear(year);
|
||||
|
||||
if(dayofyear){
|
||||
dateObject.setMonth(0);
|
||||
dateObject.setDate(Number(dayofyear));
|
||||
}
|
||||
else if(week){
|
||||
dateObject.setMonth(0);
|
||||
dateObject.setDate(1);
|
||||
var gd = dateObject.getDay();
|
||||
var day = gd ? gd : 7;
|
||||
var offset = Number(dayofweek) + (7 * Number(week));
|
||||
|
||||
if(day <= 4){ dateObject.setDate(offset + 1 - day); }
|
||||
else{ dateObject.setDate(offset + 8 - day); }
|
||||
} else{
|
||||
if(month){
|
||||
dateObject.setDate(1);
|
||||
dateObject.setMonth(month - 1);
|
||||
}
|
||||
if(date){ dateObject.setDate(date); }
|
||||
}
|
||||
|
||||
return dateObject; // Date
|
||||
};
|
||||
|
||||
dojo.date.fromIso8601Date = function(/*String*/formattedString){
|
||||
// summary: returns a Date object based on an ISO 8601 formatted string (date only)
|
||||
return dojo.date.setIso8601Date(new Date(0, 0), formattedString);
|
||||
};
|
||||
|
||||
dojo.date.setIso8601Time = function(/*Date*/dateObject, /*String*/formattedString){
|
||||
// summary: sets a Date object based on an ISO 8601 formatted string (time only)
|
||||
|
||||
// first strip timezone info from the end
|
||||
var timezone = "Z|(([-+])([0-9]{2})(:?([0-9]{2}))?)$";
|
||||
var d = formattedString.match(new RegExp(timezone));
|
||||
|
||||
var offset = 0; // local time if no tz info
|
||||
if(d){
|
||||
if(d[0] != 'Z'){
|
||||
offset = (Number(d[3]) * 60) + Number(d[5]);
|
||||
offset *= ((d[2] == '-') ? 1 : -1);
|
||||
}
|
||||
offset -= dateObject.getTimezoneOffset();
|
||||
formattedString = formattedString.substr(0, formattedString.length - d[0].length);
|
||||
}
|
||||
|
||||
// then work out the time
|
||||
var regexp = "^([0-9]{2})(:?([0-9]{2})(:?([0-9]{2})(\.([0-9]+))?)?)?$";
|
||||
d = formattedString.match(new RegExp(regexp));
|
||||
if(!d){
|
||||
dojo.debug("invalid time string: " + formattedString);
|
||||
return null; // null
|
||||
}
|
||||
var hours = d[1];
|
||||
var mins = Number((d[3]) ? d[3] : 0);
|
||||
var secs = (d[5]) ? d[5] : 0;
|
||||
var ms = d[7] ? (Number("0." + d[7]) * 1000) : 0;
|
||||
|
||||
dateObject.setHours(hours);
|
||||
dateObject.setMinutes(mins);
|
||||
dateObject.setSeconds(secs);
|
||||
dateObject.setMilliseconds(ms);
|
||||
|
||||
if(offset !== 0){
|
||||
dateObject.setTime(dateObject.getTime() + offset * 60000);
|
||||
}
|
||||
return dateObject; // Date
|
||||
};
|
||||
|
||||
dojo.date.fromIso8601Time = function(/*String*/formattedString){
|
||||
// summary: returns a Date object based on an ISO 8601 formatted string (date only)
|
||||
return dojo.date.setIso8601Time(new Date(0, 0), formattedString);
|
||||
};
|
||||
|
||||
|
||||
/* RFC-3339 Date Functions
|
||||
*************************/
|
||||
|
||||
dojo.date.toRfc3339 = function(/*Date?*/dateObject, /*String?*/selector){
|
||||
// summary:
|
||||
// Format a JavaScript Date object as a string according to RFC 3339
|
||||
//
|
||||
// dateObject:
|
||||
// A JavaScript date, or the current date and time, by default
|
||||
//
|
||||
// selector:
|
||||
// "dateOnly" or "timeOnly" to format selected portions of the Date object.
|
||||
// Date and time will be formatted by default.
|
||||
|
||||
//FIXME: tolerate Number, string input?
|
||||
if(!dateObject){
|
||||
dateObject = new Date();
|
||||
}
|
||||
|
||||
var _ = dojo.string.pad;
|
||||
var formattedDate = [];
|
||||
if(selector != "timeOnly"){
|
||||
var date = [_(dateObject.getFullYear(),4), _(dateObject.getMonth()+1,2), _(dateObject.getDate(),2)].join('-');
|
||||
formattedDate.push(date);
|
||||
}
|
||||
if(selector != "dateOnly"){
|
||||
var time = [_(dateObject.getHours(),2), _(dateObject.getMinutes(),2), _(dateObject.getSeconds(),2)].join(':');
|
||||
var timezoneOffset = dateObject.getTimezoneOffset();
|
||||
time += (timezoneOffset > 0 ? "-" : "+") +
|
||||
_(Math.floor(Math.abs(timezoneOffset)/60),2) + ":" +
|
||||
_(Math.abs(timezoneOffset)%60,2);
|
||||
formattedDate.push(time);
|
||||
}
|
||||
return formattedDate.join('T'); // String
|
||||
};
|
||||
|
||||
dojo.date.fromRfc3339 = function(/*String*/rfcDate){
|
||||
// summary:
|
||||
// Create a JavaScript Date object from a string formatted according to RFC 3339
|
||||
//
|
||||
// rfcDate:
|
||||
// A string such as 2005-06-30T08:05:00-07:00
|
||||
// "any" is also supported in place of a time.
|
||||
|
||||
// backwards compatible support for use of "any" instead of just not
|
||||
// including the time
|
||||
if(rfcDate.indexOf("Tany")!=-1){
|
||||
rfcDate = rfcDate.replace("Tany","");
|
||||
}
|
||||
var dateObject = new Date();
|
||||
return dojo.date.setIso8601(dateObject, rfcDate); // Date or null
|
||||
};
|
||||
76
source/web/scripts/ajax/dojo/src/date/supplemental.js
Normal file
76
source/web/scripts/ajax/dojo/src/date/supplemental.js
Normal file
@@ -0,0 +1,76 @@
|
||||
/*
|
||||
Copyright (c) 2004-2006, The Dojo Foundation
|
||||
All Rights Reserved.
|
||||
|
||||
Licensed under the Academic Free License version 2.1 or above OR the
|
||||
modified BSD license. For more information on Dojo licensing, see:
|
||||
|
||||
http://dojotoolkit.org/community/licensing.shtml
|
||||
*/
|
||||
|
||||
dojo.provide("dojo.date.supplemental");
|
||||
|
||||
dojo.date.getFirstDayOfWeek = function(/*String?*/locale){
|
||||
// summary: Returns a zero-based index for first day of the week
|
||||
// description:
|
||||
// Returns a zero-based index for first day of the week, as used by the local (Gregorian) calendar.
|
||||
// e.g. Sunday (returns 0), or Monday (returns 1)
|
||||
|
||||
// from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/firstDay
|
||||
var firstDay = {/*default is 1=Monday*/
|
||||
mv:5,
|
||||
ae:6,af:6,bh:6,dj:6,dz:6,eg:6,er:6,et:6,iq:6,ir:6,jo:6,ke:6,kw:6,lb:6,ly:6,ma:6,om:6,qa:6,sa:6,
|
||||
sd:6,so:6,tn:6,ye:6,
|
||||
as:0,au:0,az:0,bw:0,ca:0,cn:0,fo:0,ge:0,gl:0,gu:0,hk:0,ie:0,il:0,is:0,jm:0,jp:0,kg:0,kr:0,la:0,
|
||||
mh:0,mo:0,mp:0,mt:0,nz:0,ph:0,pk:0,sg:0,th:0,tt:0,tw:0,um:0,us:0,uz:0,vi:0,za:0,zw:0,
|
||||
et:0,mw:0,ng:0,tj:0,
|
||||
gb:0,
|
||||
sy:4
|
||||
};
|
||||
|
||||
locale = dojo.hostenv.normalizeLocale(locale);
|
||||
var country = locale.split("-")[1];
|
||||
var dow = firstDay[country];
|
||||
return (typeof dow == 'undefined') ? 1 : dow; /*Number*/
|
||||
};
|
||||
|
||||
dojo.date.getWeekend = function(/*String?*/locale){
|
||||
// summary: Returns a hash containing the start and end days of the weekend
|
||||
// description:
|
||||
// Returns a hash containing the start and end days of the weekend according to local custom using locale,
|
||||
// or by default in the user's locale.
|
||||
// e.g. {start:6, end:0}
|
||||
|
||||
// from http://www.unicode.org/cldr/data/common/supplemental/supplementalData.xml:supplementalData/weekData/weekend{Start,End}
|
||||
var weekendStart = {/*default is 6=Saturday*/
|
||||
eg:5,il:5,sy:5,
|
||||
'in':0,
|
||||
ae:4,bh:4,dz:4,iq:4,jo:4,kw:4,lb:4,ly:4,ma:4,om:4,qa:4,sa:4,sd:4,tn:4,ye:4
|
||||
};
|
||||
|
||||
var weekendEnd = {/*default is 0=Sunday*/
|
||||
ae:5,bh:5,dz:5,iq:5,jo:5,kw:5,lb:5,ly:5,ma:5,om:5,qa:5,sa:5,sd:5,tn:5,ye:5,af:5,ir:5,
|
||||
eg:6,il:6,sy:6
|
||||
};
|
||||
|
||||
locale = dojo.hostenv.normalizeLocale(locale);
|
||||
var country = locale.split("-")[1];
|
||||
var start = weekendStart[country];
|
||||
var end = weekendEnd[country];
|
||||
if(typeof start == 'undefined'){start=6;}
|
||||
if(typeof end == 'undefined'){end=0;}
|
||||
return {start:start, end:end}; /*Object {start,end}*/
|
||||
};
|
||||
|
||||
dojo.date.isWeekend = function(/*Date?*/dateObj, /*String?*/locale){
|
||||
// summary:
|
||||
// Determines if the date falls on a weekend, according to local custom.
|
||||
|
||||
var weekend = dojo.date.getWeekend(locale);
|
||||
var day = (dateObj || new Date()).getDay();
|
||||
if(weekend.end<weekend.start){
|
||||
weekend.end+=7;
|
||||
if(day<weekend.start){ day+=7; }
|
||||
}
|
||||
return day >= weekend.start && day <= weekend.end; // Boolean
|
||||
};
|
||||
Reference in New Issue
Block a user