| 1 |
// Copyright 2006 The Closure Library Authors. All Rights Reserved. |
| 2 |
// |
| 3 |
// Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 |
// you may not use this file except in compliance with the License. |
| 5 |
// You may obtain a copy of the License at |
| 6 |
// |
| 7 |
// http://www.apache.org/licenses/LICENSE-2.0 |
| 8 |
// |
| 9 |
// Unless required by applicable law or agreed to in writing, software |
| 10 |
// distributed under the License is distributed on an "AS-IS" BASIS, |
| 11 |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 |
// See the License for the specific language governing permissions and |
| 13 |
// limitations under the License. |
| 14 |
|
| 15 |
/** |
| 16 |
* @fileoverview Functions for dealing with date/time formatting. |
| 17 |
*/ |
| 18 |
|
| 19 |
|
| 20 |
/** |
| 21 |
* Namespace for i18n date/time formatting functions |
| 22 |
*/ |
| 23 |
goog.provide('goog.i18n.DateTimeFormat'); |
| 24 |
goog.provide('goog.i18n.DateTimeFormat.Format'); |
| 25 |
|
| 26 |
goog.require('goog.asserts'); |
| 27 |
goog.require('goog.date'); |
| 28 |
goog.require('goog.i18n.DateTimeSymbols'); |
| 29 |
goog.require('goog.i18n.TimeZone'); |
| 30 |
goog.require('goog.string'); |
| 31 |
|
| 32 |
|
| 33 |
/** |
| 34 |
* Datetime formatting functions following the pattern specification as defined |
| 35 |
* in JDK, ICU and CLDR, with minor modification for typical usage in JS. |
| 36 |
* Pattern specification: |
| 37 |
* {@link http://userguide.icu-project.org/formatparse/datetime} |
| 38 |
* <pre> |
| 39 |
* Symbol Meaning Presentation Example |
| 40 |
* ------ ------- ------------ ------- |
| 41 |
* G# era designator (Text) AD |
| 42 |
* y# year (Number) 1996 |
| 43 |
* Y* year (week of year) (Number) 1997 |
| 44 |
* u* extended year (Number) 4601 |
| 45 |
* Q# quarter (Text) Q3 & 3rd quarter |
| 46 |
* M month in year (Text & Number) July & 07 |
| 47 |
* L month in year (standalone) (Text & Number) July & 07 |
| 48 |
* d day in month (Number) 10 |
| 49 |
* h hour in am/pm (1~12) (Number) 12 |
| 50 |
* H hour in day (0~23) (Number) 0 |
| 51 |
* m minute in hour (Number) 30 |
| 52 |
* s second in minute (Number) 55 |
| 53 |
* S fractional second (Number) 978 |
| 54 |
* E# day of week (Text) Tue & Tuesday |
| 55 |
* e* day of week (local 1~7) (Number) 2 |
| 56 |
* c# day of week (standalone) (Text & Number) 2 & Tues & Tuesday & T |
| 57 |
* D* day in year (Number) 189 |
| 58 |
* F* day of week in month (Number) 2 (2nd Wed in July) |
| 59 |
* w week in year (Number) 27 |
| 60 |
* W* week in month (Number) 2 |
| 61 |
* a am/pm marker (Text) PM |
| 62 |
* k hour in day (1~24) (Number) 24 |
| 63 |
* K hour in am/pm (0~11) (Number) 0 |
| 64 |
* z time zone (Text) Pacific Standard Time |
| 65 |
* Z# time zone (RFC 822) (Number) -0800 |
| 66 |
* v# time zone (generic) (Text) America/Los_Angeles |
| 67 |
* V# time zone (Text) Los Angeles Time |
| 68 |
* g* Julian day (Number) 2451334 |
| 69 |
* A* milliseconds in day (Number) 69540000 |
| 70 |
* ' escape for text (Delimiter) 'Date=' |
| 71 |
* '' single quote (Literal) 'o''clock' |
| 72 |
* |
| 73 |
* Item marked with '*' are not supported yet. |
| 74 |
* Item marked with '#' works different than java |
| 75 |
* |
| 76 |
* The count of pattern letters determine the format. |
| 77 |
* (Text): 4 or more, use full form, <4, use short or abbreviated form if it |
| 78 |
* exists. (e.g., "EEEE" produces "Monday", "EEE" produces "Mon") |
| 79 |
* |
| 80 |
* (Number): the minimum number of digits. Shorter numbers are zero-padded to |
| 81 |
* this amount (e.g. if "m" produces "6", "mm" produces "06"). Year is handled |
| 82 |
* specially; that is, if the count of 'y' is 2, the Year will be truncated to |
| 83 |
* 2 digits. (e.g., if "yyyy" produces "1997", "yy" produces "97".) Unlike other |
| 84 |
* fields, fractional seconds are padded on the right with zero. |
| 85 |
* |
| 86 |
* :(Text & Number) 3 or over, use text, otherwise use number. (e.g., "M" |
| 87 |
* produces "1", "MM" produces "01", "MMM" produces "Jan", and "MMMM" produces |
| 88 |
* "January".) |
| 89 |
* |
| 90 |
* Any characters in the pattern that are not in the ranges of ['a'..'z'] and |
| 91 |
* ['A'..'Z'] will be treated as quoted text. For instance, characters like ':', |
| 92 |
* '.', ' ', '#' and '@' will appear in the resulting time text even they are |
| 93 |
* not embraced within single quotes. |
| 94 |
* </pre> |
| 95 |
*/ |
| 96 |
|
| 97 |
/** |
| 98 |
* Construct a DateTimeFormat object based on current locale. |
| 99 |
* @constructor |
| 100 |
* @param {string|number} pattern pattern specification or pattern type. |
| 101 |
* @param {!Object=} opt_dateTimeSymbols Optional symbols to use for this |
| 102 |
* instance rather than the global symbols. |
| 103 |
* @final |
| 104 |
*/ |
| 105 |
goog.i18n.DateTimeFormat = function(pattern, opt_dateTimeSymbols) { |
| 106 |
goog.asserts.assert(goog.isDef(pattern), 'Pattern must be defined'); |
| 107 |
goog.asserts.assert( |
| 108 |
goog.isDef(opt_dateTimeSymbols) || goog.isDef(goog.i18n.DateTimeSymbols), |
| 109 |
'goog.i18n.DateTimeSymbols or explicit symbols must be defined'); |
| 110 |
|
| 111 |
this.patternParts_ = []; |
| 112 |
|
| 113 |
/** |
| 114 |
* Data structure that with all the locale info needed for date formatting. |
| 115 |
* (day/month names, most common patterns, rules for week-end, etc.) |
| 116 |
* @private {!goog.i18n.DateTimeSymbolsType} |
| 117 |
*/ |
| 118 |
this.dateTimeSymbols_ = /** @type {!goog.i18n.DateTimeSymbolsType} */ ( |
| 119 |
opt_dateTimeSymbols || goog.i18n.DateTimeSymbols); |
| 120 |
if (typeof pattern == 'number') { |
| 121 |
this.applyStandardPattern_(pattern); |
| 122 |
} else { |
| 123 |
this.applyPattern_(pattern); |
| 124 |
} |
| 125 |
}; |
| 126 |
|
| 127 |
|
| 128 |
/** |
| 129 |
* Enum to identify predefined Date/Time format pattern. |
| 130 |
* @enum {number} |
| 131 |
*/ |
| 132 |
goog.i18n.DateTimeFormat.Format = { |
| 133 |
FULL_DATE: 0, |
| 134 |
LONG_DATE: 1, |
| 135 |
MEDIUM_DATE: 2, |
| 136 |
SHORT_DATE: 3, |
| 137 |
FULL_TIME: 4, |
| 138 |
LONG_TIME: 5, |
| 139 |
MEDIUM_TIME: 6, |
| 140 |
SHORT_TIME: 7, |
| 141 |
FULL_DATETIME: 8, |
| 142 |
LONG_DATETIME: 9, |
| 143 |
MEDIUM_DATETIME: 10, |
| 144 |
SHORT_DATETIME: 11 |
| 145 |
}; |
| 146 |
|
| 147 |
|
| 148 |
/** |
| 149 |
* regular expression pattern for parsing pattern string |
| 150 |
* @type {Array<RegExp>} |
| 151 |
* @private |
| 152 |
*/ |
| 153 |
goog.i18n.DateTimeFormat.TOKENS_ = [ |
| 154 |
// quote string |
| 155 |
/^\'(?:[^\']|\'\')*(\'|$)/, |
| 156 |
// pattern chars |
| 157 |
/^(?:G+|y+|M+|k+|S+|E+|a+|h+|K+|H+|c+|L+|Q+|d+|m+|s+|v+|V+|w+|z+|Z+)/, |
| 158 |
// and all the other chars |
| 159 |
/^[^\'GyMkSEahKHcLQdmsvVwzZ]+/ // and all the other chars |
| 160 |
]; |
| 161 |
|
| 162 |
|
| 163 |
/** |
| 164 |
* These are token types, corresponding to above token definitions. |
| 165 |
* @enum {number} |
| 166 |
* @private |
| 167 |
*/ |
| 168 |
goog.i18n.DateTimeFormat.PartTypes_ = { |
| 169 |
QUOTED_STRING: 0, |
| 170 |
FIELD: 1, |
| 171 |
LITERAL: 2 |
| 172 |
}; |
| 173 |
|
| 174 |
|
| 175 |
/** |
| 176 |
* @param {!goog.date.DateLike} date |
| 177 |
* @return {number} |
| 178 |
* @private |
| 179 |
*/ |
| 180 |
goog.i18n.DateTimeFormat.getHours_ = function(date) { |
| 181 |
return date.getHours ? date.getHours() : 0; |
| 182 |
}; |
| 183 |
|
| 184 |
|
| 185 |
/** |
| 186 |
* Apply specified pattern to this formatter object. |
| 187 |
* @param {string} pattern String specifying how the date should be formatted. |
| 188 |
* @private |
| 189 |
*/ |
| 190 |
goog.i18n.DateTimeFormat.prototype.applyPattern_ = function(pattern) { |
| 191 |
if (goog.i18n.DateTimeFormat.removeRlmInPatterns_) { |
| 192 |
// Remove RLM unicode control character from pattern. |
| 193 |
pattern = pattern.replace(/\u200f/g, ''); |
| 194 |
} |
| 195 |
// lex the pattern, once for all uses |
| 196 |
while (pattern) { |
| 197 |
var previousPattern = pattern; |
| 198 |
for (var i = 0; i < goog.i18n.DateTimeFormat.TOKENS_.length; ++i) { |
| 199 |
var m = pattern.match(goog.i18n.DateTimeFormat.TOKENS_[i]); |
| 200 |
if (m) { |
| 201 |
var part = m[0]; |
| 202 |
pattern = pattern.substring(part.length); |
| 203 |
if (i == goog.i18n.DateTimeFormat.PartTypes_.QUOTED_STRING) { |
| 204 |
if (part == "''") { |
| 205 |
part = "'"; // '' -> ' |
| 206 |
} else { |
| 207 |
part = part.substring( |
| 208 |
1, |
| 209 |
m[1] == '\'' ? part.length - 1 : part.length); // strip quotes |
| 210 |
part = part.replace(/\'\'/g, '\''); |
| 211 |
} |
| 212 |
} |
| 213 |
this.patternParts_.push({text: part, type: i}); |
| 214 |
break; |
| 215 |
} |
| 216 |
} |
| 217 |
if (previousPattern === pattern) { |
| 218 |
// On every iteration, part of the pattern string must be consumed. |
| 219 |
throw new Error('Malformed pattern part: ' + pattern); |
| 220 |
} |
| 221 |
} |
| 222 |
}; |
| 223 |
|
| 224 |
|
| 225 |
/** |
| 226 |
* Format the given date object according to preset pattern and current locale. |
| 227 |
* @param {goog.date.DateLike} date The Date object that is being formatted. |
| 228 |
* @param {goog.i18n.TimeZone=} opt_timeZone optional, if specified, time |
| 229 |
* related fields will be formatted based on its setting. When this field |
| 230 |
* is not specified, "undefined" will be pass around and those function |
| 231 |
* that really need time zone service will create a default one. |
| 232 |
* @return {string} Formatted string for the given date. |
| 233 |
* Throws an error if the date is null or if one tries to format a date-only |
| 234 |
* object (for instance goog.date.Date) using a pattern with time fields. |
| 235 |
*/ |
| 236 |
goog.i18n.DateTimeFormat.prototype.format = function(date, opt_timeZone) { |
| 237 |
if (!date) throw new Error('The date to format must be non-null.'); |
| 238 |
|
| 239 |
// We don't want to write code to calculate each date field because we |
| 240 |
// want to maximize performance and minimize code size. |
| 241 |
// JavaScript only provide API to render local time. |
| 242 |
// Suppose target date is: 16:00 GMT-0400 |
| 243 |
// OS local time is: 12:00 GMT-0800 |
| 244 |
// We want to create a Local Date Object : 16:00 GMT-0800, and fix the |
| 245 |
// time zone display ourselves. |
| 246 |
// Thing get a little bit tricky when daylight time transition happens. For |
| 247 |
// example, suppose OS timeZone is America/Los_Angeles, it is impossible to |
| 248 |
// represent "2006/4/2 02:30" even for those timeZone that has no transition |
| 249 |
// at this time. Because 2:00 to 3:00 on that day does not exist in |
| 250 |
// America/Los_Angeles time zone. To avoid calculating date field through |
| 251 |
// our own code, we uses 3 Date object instead, one for "Year, month, day", |
| 252 |
// one for time within that day, and one for timeZone object since it need |
| 253 |
// the real time to figure out actual time zone offset. |
| 254 |
var diff = opt_timeZone ? |
| 255 |
(date.getTimezoneOffset() - opt_timeZone.getOffset(date)) * 60000 : |
| 256 |
0; |
| 257 |
var dateForDate = diff ? new Date(date.getTime() + diff) : date; |
| 258 |
var dateForTime = dateForDate; |
| 259 |
// When the time manipulation applied above spans the DST on/off hour, this |
| 260 |
// could alter the time incorrectly by adding or subtracting an additional |
| 261 |
// hour. |
| 262 |
// We can mitigate this by: |
| 263 |
// - Adding the difference in timezone offset to the date. This ensures that |
| 264 |
// the dateForDate is still within the right day if the extra DST hour |
| 265 |
// affected the date. |
| 266 |
// - Move the time one day forward if we applied a timezone offset backwards, |
| 267 |
// or vice versa. This trick ensures that the time is in the same offset |
| 268 |
// as the original date, so we remove the additional hour added or |
| 269 |
// subtracted by the DST switch. |
| 270 |
if (opt_timeZone && |
| 271 |
dateForDate.getTimezoneOffset() != date.getTimezoneOffset()) { |
| 272 |
var dstDiff = |
| 273 |
(dateForDate.getTimezoneOffset() - date.getTimezoneOffset()) * 60000; |
| 274 |
dateForDate = new Date(dateForDate.getTime() + dstDiff); |
| 275 |
|
| 276 |
diff += diff > 0 ? -goog.date.MS_PER_DAY : goog.date.MS_PER_DAY; |
| 277 |
dateForTime = new Date(date.getTime() + diff); |
| 278 |
} |
| 279 |
|
| 280 |
var out = []; |
| 281 |
for (var i = 0; i < this.patternParts_.length; ++i) { |
| 282 |
var text = this.patternParts_[i].text; |
| 283 |
if (goog.i18n.DateTimeFormat.PartTypes_.FIELD == |
| 284 |
this.patternParts_[i].type) { |
| 285 |
out.push( |
| 286 |
this.formatField_( |
| 287 |
text, date, dateForDate, dateForTime, opt_timeZone)); |
| 288 |
} else { |
| 289 |
out.push(text); |
| 290 |
} |
| 291 |
} |
| 292 |
return out.join(''); |
| 293 |
}; |
| 294 |
|
| 295 |
|
| 296 |
/** |
| 297 |
* Apply a predefined pattern as identified by formatType, which is stored in |
| 298 |
* locale specific repository. |
| 299 |
* @param {number} formatType A number that identified the predefined pattern. |
| 300 |
* @private |
| 301 |
*/ |
| 302 |
goog.i18n.DateTimeFormat.prototype.applyStandardPattern_ = function( |
| 303 |
formatType) { |
| 304 |
var pattern; |
| 305 |
if (formatType < 4) { |
| 306 |
pattern = this.dateTimeSymbols_.DATEFORMATS[formatType]; |
| 307 |
} else if (formatType < 8) { |
| 308 |
pattern = this.dateTimeSymbols_.TIMEFORMATS[formatType - 4]; |
| 309 |
} else if (formatType < 12) { |
| 310 |
pattern = this.dateTimeSymbols_.DATETIMEFORMATS[formatType - 8]; |
| 311 |
pattern = pattern.replace( |
| 312 |
'{1}', this.dateTimeSymbols_.DATEFORMATS[formatType - 8]); |
| 313 |
pattern = pattern.replace( |
| 314 |
'{0}', this.dateTimeSymbols_.TIMEFORMATS[formatType - 8]); |
| 315 |
} else { |
| 316 |
this.applyStandardPattern_(goog.i18n.DateTimeFormat.Format.MEDIUM_DATETIME); |
| 317 |
return; |
| 318 |
} |
| 319 |
this.applyPattern_(pattern); |
| 320 |
}; |
| 321 |
|
| 322 |
|
| 323 |
/** |
| 324 |
* Localizes a string potentially containing numbers, replacing ASCII digits |
| 325 |
* with native digits if specified so by the locale. Leaves other characters. |
| 326 |
* @param {string} input the string to be localized, using ASCII digits. |
| 327 |
* @return {string} localized string, potentially using native digits. |
| 328 |
* @private |
| 329 |
*/ |
| 330 |
goog.i18n.DateTimeFormat.prototype.localizeNumbers_ = function(input) { |
| 331 |
return goog.i18n.DateTimeFormat.localizeNumbers(input, this.dateTimeSymbols_); |
| 332 |
}; |
| 333 |
|
| 334 |
|
| 335 |
/** |
| 336 |
* If the usage of Ascii digits should be enforced regardless of locale. |
| 337 |
* @type {boolean} |
| 338 |
* @private |
| 339 |
*/ |
| 340 |
goog.i18n.DateTimeFormat.enforceAsciiDigits_ = false; |
| 341 |
|
| 342 |
|
| 343 |
/** |
| 344 |
* If RLM unicode characters should be removed from date/time patterns (useful |
| 345 |
* when enforcing ASCII digits for Arabic). See {@code #setEnforceAsciiDigits}. |
| 346 |
* @type {boolean} |
| 347 |
* @private |
| 348 |
*/ |
| 349 |
goog.i18n.DateTimeFormat.removeRlmInPatterns_ = false; |
| 350 |
|
| 351 |
|
| 352 |
/** |
| 353 |
* Sets if the usage of Ascii digits in formatting should be enforced in |
| 354 |
* formatted date/time even for locales where native digits are indicated. |
| 355 |
* Also sets whether to remove RLM unicode control characters when using |
| 356 |
* standard enumerated patterns (they exist e.g. in standard d/M/y for Arabic). |
| 357 |
* Production code should call this once before any {@code DateTimeFormat} |
| 358 |
* object is instantiated. |
| 359 |
* Caveats: |
| 360 |
* * Enforcing ASCII digits affects all future formatting by new or existing |
| 361 |
* {@code DateTimeFormat} objects. |
| 362 |
* * Removal of RLM characters only applies to {@code DateTimeFormat} objects |
| 363 |
* instantiated after this call. |
| 364 |
* @param {boolean} enforceAsciiDigits Whether Ascii digits should be enforced. |
| 365 |
*/ |
| 366 |
goog.i18n.DateTimeFormat.setEnforceAsciiDigits = function(enforceAsciiDigits) { |
| 367 |
goog.i18n.DateTimeFormat.enforceAsciiDigits_ = enforceAsciiDigits; |
| 368 |
|
| 369 |
// Also setting removal of RLM chracters when forcing ASCII digits since it's |
| 370 |
// the right thing to do for Arabic standard patterns. One could add an |
| 371 |
// optional argument here or to the {@code DateTimeFormat} constructor to |
| 372 |
// enable an alternative behavior. |
| 373 |
goog.i18n.DateTimeFormat.removeRlmInPatterns_ = enforceAsciiDigits; |
| 374 |
}; |
| 375 |
|
| 376 |
|
| 377 |
/** |
| 378 |
* @return {boolean} Whether enforcing ASCII digits for all locales. See |
| 379 |
* {@code #setEnforceAsciiDigits} for more details. |
| 380 |
*/ |
| 381 |
goog.i18n.DateTimeFormat.isEnforceAsciiDigits = function() { |
| 382 |
return goog.i18n.DateTimeFormat.enforceAsciiDigits_; |
| 383 |
}; |
| 384 |
|
| 385 |
|
| 386 |
/** |
| 387 |
* Localizes a string potentially containing numbers, replacing ASCII digits |
| 388 |
* with native digits if specified so by the locale. Leaves other characters. |
| 389 |
* @param {number|string} input the string to be localized, using ASCII digits. |
| 390 |
* @param {!Object=} opt_dateTimeSymbols Optional symbols to use rather than |
| 391 |
* the global symbols. |
| 392 |
* @return {string} localized string, potentially using native digits. |
| 393 |
*/ |
| 394 |
goog.i18n.DateTimeFormat.localizeNumbers = function( |
| 395 |
input, opt_dateTimeSymbols) { |
| 396 |
input = String(input); |
| 397 |
var dateTimeSymbols = opt_dateTimeSymbols || goog.i18n.DateTimeSymbols; |
| 398 |
if (dateTimeSymbols.ZERODIGIT === undefined || |
| 399 |
goog.i18n.DateTimeFormat.enforceAsciiDigits_) { |
| 400 |
return input; |
| 401 |
} |
| 402 |
|
| 403 |
var parts = []; |
| 404 |
for (var i = 0; i < input.length; i++) { |
| 405 |
var c = input.charCodeAt(i); |
| 406 |
parts.push( |
| 407 |
(0x30 <= c && c <= 0x39) ? // '0' <= c <= '9' |
| 408 |
String.fromCharCode(dateTimeSymbols.ZERODIGIT + c - 0x30) : |
| 409 |
input.charAt(i)); |
| 410 |
} |
| 411 |
return parts.join(''); |
| 412 |
}; |
| 413 |
|
| 414 |
|
| 415 |
/** |
| 416 |
* Formats Era field according to pattern specified. |
| 417 |
* |
| 418 |
* @param {number} count Number of time pattern char repeats, it controls |
| 419 |
* how a field should be formatted. |
| 420 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 421 |
* @return {string} Formatted string that represent this field. |
| 422 |
* @private |
| 423 |
*/ |
| 424 |
goog.i18n.DateTimeFormat.prototype.formatEra_ = function(count, date) { |
| 425 |
var value = date.getFullYear() > 0 ? 1 : 0; |
| 426 |
return count >= 4 ? this.dateTimeSymbols_.ERANAMES[value] : |
| 427 |
this.dateTimeSymbols_.ERAS[value]; |
| 428 |
}; |
| 429 |
|
| 430 |
|
| 431 |
/** |
| 432 |
* Formats Year field according to pattern specified |
| 433 |
* Javascript Date object seems incapable handling 1BC and |
| 434 |
* year before. It can show you year 0 which does not exists. |
| 435 |
* following we just keep consistent with javascript's |
| 436 |
* toString method. But keep in mind those things should be |
| 437 |
* unsupported. |
| 438 |
* @param {number} count Number of time pattern char repeats, it controls |
| 439 |
* how a field should be formatted. |
| 440 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 441 |
* @return {string} Formatted string that represent this field. |
| 442 |
* @private |
| 443 |
*/ |
| 444 |
goog.i18n.DateTimeFormat.prototype.formatYear_ = function(count, date) { |
| 445 |
var value = date.getFullYear(); |
| 446 |
if (value < 0) { |
| 447 |
value = -value; |
| 448 |
} |
| 449 |
if (count == 2) { |
| 450 |
// See comment about special casing 'yy' at the start of the file, this |
| 451 |
// matches ICU and CLDR behaviour. See also: |
| 452 |
// http://icu-project.org/apiref/icu4j/com/ibm/icu/text/SimpleDateFormat.html |
| 453 |
// http://www.unicode.org/reports/tr35/tr35-dates.html |
| 454 |
value = value % 100; |
| 455 |
} |
| 456 |
return this.localizeNumbers_(goog.string.padNumber(value, count)); |
| 457 |
}; |
| 458 |
|
| 459 |
|
| 460 |
/** |
| 461 |
* Formats Month field according to pattern specified |
| 462 |
* |
| 463 |
* @param {number} count Number of time pattern char repeats, it controls |
| 464 |
* how a field should be formatted. |
| 465 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 466 |
* @return {string} Formatted string that represent this field. |
| 467 |
* @private |
| 468 |
*/ |
| 469 |
goog.i18n.DateTimeFormat.prototype.formatMonth_ = function(count, date) { |
| 470 |
var value = date.getMonth(); |
| 471 |
switch (count) { |
| 472 |
case 5: |
| 473 |
return this.dateTimeSymbols_.NARROWMONTHS[value]; |
| 474 |
case 4: |
| 475 |
return this.dateTimeSymbols_.MONTHS[value]; |
| 476 |
case 3: |
| 477 |
return this.dateTimeSymbols_.SHORTMONTHS[value]; |
| 478 |
default: |
| 479 |
return this.localizeNumbers_(goog.string.padNumber(value + 1, count)); |
| 480 |
} |
| 481 |
}; |
| 482 |
|
| 483 |
|
| 484 |
/** |
| 485 |
* Validates is the goog.date.DateLike object to format has a time. |
| 486 |
* DateLike means Date|goog.date.Date, and goog.date.DateTime inherits |
| 487 |
* from goog.date.Date. But goog.date.Date does not have time related |
| 488 |
* members (getHours, getMinutes, getSeconds). |
| 489 |
* Formatting can be done, if there are no time placeholders in the pattern. |
| 490 |
* |
| 491 |
* @param {!goog.date.DateLike} date the object to validate. |
| 492 |
* @private |
| 493 |
*/ |
| 494 |
goog.i18n.DateTimeFormat.validateDateHasTime_ = function(date) { |
| 495 |
if (date.getHours && date.getSeconds && date.getMinutes) return; |
| 496 |
// if (date instanceof Date || date instanceof goog.date.DateTime) |
| 497 |
throw new Error( |
| 498 |
'The date to format has no time (probably a goog.date.Date). ' + |
| 499 |
'Use Date or goog.date.DateTime, or use a pattern without time fields.'); |
| 500 |
}; |
| 501 |
|
| 502 |
|
| 503 |
/** |
| 504 |
* Formats (1..24) Hours field according to pattern specified |
| 505 |
* |
| 506 |
* @param {number} count Number of time pattern char repeats. This controls |
| 507 |
* how a field should be formatted. |
| 508 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 509 |
* @return {string} Formatted string that represent this field. |
| 510 |
* @private |
| 511 |
*/ |
| 512 |
goog.i18n.DateTimeFormat.prototype.format24Hours_ = function(count, date) { |
| 513 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 514 |
var hours = goog.i18n.DateTimeFormat.getHours_(date) || 24; |
| 515 |
return this.localizeNumbers_(goog.string.padNumber(hours, count)); |
| 516 |
}; |
| 517 |
|
| 518 |
|
| 519 |
/** |
| 520 |
* Formats Fractional seconds field according to pattern |
| 521 |
* specified |
| 522 |
* |
| 523 |
* @param {number} count Number of time pattern char repeats, it controls |
| 524 |
* how a field should be formatted. |
| 525 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 526 |
* |
| 527 |
* @return {string} Formatted string that represent this field. |
| 528 |
* @private |
| 529 |
*/ |
| 530 |
goog.i18n.DateTimeFormat.prototype.formatFractionalSeconds_ = function( |
| 531 |
count, date) { |
| 532 |
// Fractional seconds left-justify, append 0 for precision beyond 3 |
| 533 |
var value = date.getTime() % 1000 / 1000; |
| 534 |
return this.localizeNumbers_( |
| 535 |
value.toFixed(Math.min(3, count)).substr(2) + |
| 536 |
(count > 3 ? goog.string.padNumber(0, count - 3) : '')); |
| 537 |
}; |
| 538 |
|
| 539 |
|
| 540 |
/** |
| 541 |
* Formats Day of week field according to pattern specified |
| 542 |
* |
| 543 |
* @param {number} count Number of time pattern char repeats, it controls |
| 544 |
* how a field should be formatted. |
| 545 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 546 |
* @return {string} Formatted string that represent this field. |
| 547 |
* @private |
| 548 |
*/ |
| 549 |
goog.i18n.DateTimeFormat.prototype.formatDayOfWeek_ = function(count, date) { |
| 550 |
var value = date.getDay(); |
| 551 |
return count >= 4 ? this.dateTimeSymbols_.WEEKDAYS[value] : |
| 552 |
this.dateTimeSymbols_.SHORTWEEKDAYS[value]; |
| 553 |
}; |
| 554 |
|
| 555 |
|
| 556 |
/** |
| 557 |
* Formats Am/Pm field according to pattern specified |
| 558 |
* |
| 559 |
* @param {number} count Number of time pattern char repeats, it controls |
| 560 |
* how a field should be formatted. |
| 561 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 562 |
* @return {string} Formatted string that represent this field. |
| 563 |
* @private |
| 564 |
*/ |
| 565 |
goog.i18n.DateTimeFormat.prototype.formatAmPm_ = function(count, date) { |
| 566 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 567 |
var hours = goog.i18n.DateTimeFormat.getHours_(date); |
| 568 |
return this.dateTimeSymbols_.AMPMS[hours >= 12 && hours < 24 ? 1 : 0]; |
| 569 |
}; |
| 570 |
|
| 571 |
|
| 572 |
/** |
| 573 |
* Formats (1..12) Hours field according to pattern specified |
| 574 |
* |
| 575 |
* @param {number} count Number of time pattern char repeats, it controls |
| 576 |
* how a field should be formatted. |
| 577 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 578 |
* @return {string} formatted string that represent this field. |
| 579 |
* @private |
| 580 |
*/ |
| 581 |
goog.i18n.DateTimeFormat.prototype.format1To12Hours_ = function(count, date) { |
| 582 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 583 |
var hours = goog.i18n.DateTimeFormat.getHours_(date) % 12 || 12; |
| 584 |
return this.localizeNumbers_(goog.string.padNumber(hours, count)); |
| 585 |
}; |
| 586 |
|
| 587 |
|
| 588 |
/** |
| 589 |
* Formats (0..11) Hours field according to pattern specified |
| 590 |
* |
| 591 |
* @param {number} count Number of time pattern char repeats, it controls |
| 592 |
* how a field should be formatted. |
| 593 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 594 |
* @return {string} formatted string that represent this field. |
| 595 |
* @private |
| 596 |
*/ |
| 597 |
goog.i18n.DateTimeFormat.prototype.format0To11Hours_ = function(count, date) { |
| 598 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 599 |
var hours = goog.i18n.DateTimeFormat.getHours_(date) % 12; |
| 600 |
return this.localizeNumbers_(goog.string.padNumber(hours, count)); |
| 601 |
}; |
| 602 |
|
| 603 |
|
| 604 |
/** |
| 605 |
* Formats (0..23) Hours field according to pattern specified |
| 606 |
* |
| 607 |
* @param {number} count Number of time pattern char repeats, it controls |
| 608 |
* how a field should be formatted. |
| 609 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 610 |
* @return {string} formatted string that represent this field. |
| 611 |
* @private |
| 612 |
*/ |
| 613 |
goog.i18n.DateTimeFormat.prototype.format0To23Hours_ = function(count, date) { |
| 614 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 615 |
var hours = goog.i18n.DateTimeFormat.getHours_(date); |
| 616 |
return this.localizeNumbers_(goog.string.padNumber(hours, count)); |
| 617 |
}; |
| 618 |
|
| 619 |
|
| 620 |
/** |
| 621 |
* Formats Standalone weekday field according to pattern specified |
| 622 |
* |
| 623 |
* @param {number} count Number of time pattern char repeats, it controls |
| 624 |
* how a field should be formatted. |
| 625 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 626 |
* @return {string} formatted string that represent this field. |
| 627 |
* @private |
| 628 |
*/ |
| 629 |
goog.i18n.DateTimeFormat.prototype.formatStandaloneDay_ = function( |
| 630 |
count, date) { |
| 631 |
var value = date.getDay(); |
| 632 |
switch (count) { |
| 633 |
case 5: |
| 634 |
return this.dateTimeSymbols_.STANDALONENARROWWEEKDAYS[value]; |
| 635 |
case 4: |
| 636 |
return this.dateTimeSymbols_.STANDALONEWEEKDAYS[value]; |
| 637 |
case 3: |
| 638 |
return this.dateTimeSymbols_.STANDALONESHORTWEEKDAYS[value]; |
| 639 |
default: |
| 640 |
return this.localizeNumbers_(goog.string.padNumber(value, 1)); |
| 641 |
} |
| 642 |
}; |
| 643 |
|
| 644 |
|
| 645 |
/** |
| 646 |
* Formats Standalone Month field according to pattern specified |
| 647 |
* |
| 648 |
* @param {number} count Number of time pattern char repeats, it controls |
| 649 |
* how a field should be formatted. |
| 650 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 651 |
* @return {string} formatted string that represent this field. |
| 652 |
* @private |
| 653 |
*/ |
| 654 |
goog.i18n.DateTimeFormat.prototype.formatStandaloneMonth_ = function( |
| 655 |
count, date) { |
| 656 |
var value = date.getMonth(); |
| 657 |
switch (count) { |
| 658 |
case 5: |
| 659 |
return this.dateTimeSymbols_.STANDALONENARROWMONTHS[value]; |
| 660 |
case 4: |
| 661 |
return this.dateTimeSymbols_.STANDALONEMONTHS[value]; |
| 662 |
case 3: |
| 663 |
return this.dateTimeSymbols_.STANDALONESHORTMONTHS[value]; |
| 664 |
default: |
| 665 |
return this.localizeNumbers_(goog.string.padNumber(value + 1, count)); |
| 666 |
} |
| 667 |
}; |
| 668 |
|
| 669 |
|
| 670 |
/** |
| 671 |
* Formats Quarter field according to pattern specified |
| 672 |
* |
| 673 |
* @param {number} count Number of time pattern char repeats, it controls |
| 674 |
* how a field should be formatted. |
| 675 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 676 |
* @return {string} Formatted string that represent this field. |
| 677 |
* @private |
| 678 |
*/ |
| 679 |
goog.i18n.DateTimeFormat.prototype.formatQuarter_ = function(count, date) { |
| 680 |
var value = Math.floor(date.getMonth() / 3); |
| 681 |
return count < 4 ? this.dateTimeSymbols_.SHORTQUARTERS[value] : |
| 682 |
this.dateTimeSymbols_.QUARTERS[value]; |
| 683 |
}; |
| 684 |
|
| 685 |
|
| 686 |
/** |
| 687 |
* Formats Date field according to pattern specified |
| 688 |
* |
| 689 |
* @param {number} count Number of time pattern char repeats, it controls |
| 690 |
* how a field should be formatted. |
| 691 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 692 |
* @return {string} Formatted string that represent this field. |
| 693 |
* @private |
| 694 |
*/ |
| 695 |
goog.i18n.DateTimeFormat.prototype.formatDate_ = function(count, date) { |
| 696 |
return this.localizeNumbers_(goog.string.padNumber(date.getDate(), count)); |
| 697 |
}; |
| 698 |
|
| 699 |
|
| 700 |
/** |
| 701 |
* Formats Minutes field according to pattern specified |
| 702 |
* |
| 703 |
* @param {number} count Number of time pattern char repeats, it controls |
| 704 |
* how a field should be formatted. |
| 705 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 706 |
* @return {string} Formatted string that represent this field. |
| 707 |
* @private |
| 708 |
*/ |
| 709 |
goog.i18n.DateTimeFormat.prototype.formatMinutes_ = function(count, date) { |
| 710 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 711 |
return this.localizeNumbers_( |
| 712 |
goog.string.padNumber( |
| 713 |
/** @type {!goog.date.DateTime} */ (date).getMinutes(), count)); |
| 714 |
}; |
| 715 |
|
| 716 |
|
| 717 |
/** |
| 718 |
* Formats Seconds field according to pattern specified |
| 719 |
* |
| 720 |
* @param {number} count Number of time pattern char repeats, it controls |
| 721 |
* how a field should be formatted. |
| 722 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 723 |
* @return {string} Formatted string that represent this field. |
| 724 |
* @private |
| 725 |
*/ |
| 726 |
goog.i18n.DateTimeFormat.prototype.formatSeconds_ = function(count, date) { |
| 727 |
goog.i18n.DateTimeFormat.validateDateHasTime_(date); |
| 728 |
return this.localizeNumbers_( |
| 729 |
goog.string.padNumber( |
| 730 |
/** @type {!goog.date.DateTime} */ (date).getSeconds(), count)); |
| 731 |
}; |
| 732 |
|
| 733 |
|
| 734 |
/** |
| 735 |
* Formats the week of year field according to pattern specified |
| 736 |
* |
| 737 |
* @param {number} count Number of time pattern char repeats, it controls |
| 738 |
* how a field should be formatted. |
| 739 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 740 |
* @return {string} Formatted string that represent this field. |
| 741 |
* @private |
| 742 |
*/ |
| 743 |
goog.i18n.DateTimeFormat.prototype.formatWeekOfYear_ = function(count, date) { |
| 744 |
|
| 745 |
|
| 746 |
var weekNum = goog.date.getWeekNumber( |
| 747 |
date.getFullYear(), date.getMonth(), date.getDate(), |
| 748 |
this.dateTimeSymbols_.FIRSTWEEKCUTOFFDAY, |
| 749 |
this.dateTimeSymbols_.FIRSTDAYOFWEEK); |
| 750 |
|
| 751 |
return this.localizeNumbers_(goog.string.padNumber(weekNum, count)); |
| 752 |
}; |
| 753 |
|
| 754 |
|
| 755 |
/** |
| 756 |
* Formats TimeZone field following RFC |
| 757 |
* |
| 758 |
* @param {number} count Number of time pattern char repeats, it controls |
| 759 |
* how a field should be formatted. |
| 760 |
* @param {!goog.date.DateLike} date It holds the date object to be formatted. |
| 761 |
* @param {goog.i18n.TimeZone=} opt_timeZone This holds current time zone info. |
| 762 |
* @return {string} Formatted string that represent this field. |
| 763 |
* @private |
| 764 |
*/ |
| 765 |
goog.i18n.DateTimeFormat.prototype.formatTimeZoneRFC_ = function( |
| 766 |
count, date, opt_timeZone) { |
| 767 |
opt_timeZone = opt_timeZone || |
| 768 |
goog.i18n.TimeZone.createTimeZone(date.getTimezoneOffset()); |
| 769 |
|
| 770 |
// RFC 822 formats should be kept in ASCII, but localized GMT formats may need |
| 771 |
// to use native digits. |
| 772 |
return count < 4 ? opt_timeZone.getRFCTimeZoneString(date) : |
| 773 |
this.localizeNumbers_(opt_timeZone.getGMTString(date)); |
| 774 |
}; |
| 775 |
|
| 776 |
|
| 777 |
/** |
| 778 |
* Generate GMT timeZone string for given date |
| 779 |
* @param {number} count Number of time pattern char repeats, it controls |
| 780 |
* how a field should be formatted. |
| 781 |
* @param {!goog.date.DateLike} date Whose value being evaluated. |
| 782 |
* @param {goog.i18n.TimeZone=} opt_timeZone This holds current time zone info. |
| 783 |
* @return {string} GMT timeZone string. |
| 784 |
* @private |
| 785 |
*/ |
| 786 |
goog.i18n.DateTimeFormat.prototype.formatTimeZone_ = function( |
| 787 |
count, date, opt_timeZone) { |
| 788 |
opt_timeZone = opt_timeZone || |
| 789 |
goog.i18n.TimeZone.createTimeZone(date.getTimezoneOffset()); |
| 790 |
return count < 4 ? opt_timeZone.getShortName(date) : |
| 791 |
opt_timeZone.getLongName(date); |
| 792 |
}; |
| 793 |
|
| 794 |
|
| 795 |
/** |
| 796 |
* Generate GMT timeZone string for given date |
| 797 |
* @param {!goog.date.DateLike} date Whose value being evaluated. |
| 798 |
* @param {goog.i18n.TimeZone=} opt_timeZone This holds current time zone info. |
| 799 |
* @return {string} GMT timeZone string. |
| 800 |
* @private |
| 801 |
*/ |
| 802 |
goog.i18n.DateTimeFormat.prototype.formatTimeZoneId_ = function( |
| 803 |
date, opt_timeZone) { |
| 804 |
opt_timeZone = opt_timeZone || |
| 805 |
goog.i18n.TimeZone.createTimeZone(date.getTimezoneOffset()); |
| 806 |
return opt_timeZone.getTimeZoneId(); |
| 807 |
}; |
| 808 |
|
| 809 |
|
| 810 |
/** |
| 811 |
* Generate localized, location dependent time zone id |
| 812 |
* @param {number} count Number of time pattern char repeats, it controls |
| 813 |
* how a field should be formatted. |
| 814 |
* @param {!goog.date.DateLike} date Whose value being evaluated. |
| 815 |
* @param {goog.i18n.TimeZone=} opt_timeZone This holds current time zone info. |
| 816 |
* @return {string} GMT timeZone string. |
| 817 |
* @private |
| 818 |
*/ |
| 819 |
goog.i18n.DateTimeFormat.prototype.formatTimeZoneLocationId_ = function( |
| 820 |
count, date, opt_timeZone) { |
| 821 |
opt_timeZone = opt_timeZone || |
| 822 |
goog.i18n.TimeZone.createTimeZone(date.getTimezoneOffset()); |
| 823 |
return count <= 2 ? opt_timeZone.getTimeZoneId() : |
| 824 |
opt_timeZone.getGenericLocation(date); |
| 825 |
}; |
| 826 |
|
| 827 |
|
| 828 |
/** |
| 829 |
* Formatting one date field. |
| 830 |
* @param {string} patternStr The pattern string for the field being formatted. |
| 831 |
* @param {!goog.date.DateLike} date represents the real date to be formatted. |
| 832 |
* @param {!goog.date.DateLike} dateForDate used to resolve date fields |
| 833 |
* for formatting. |
| 834 |
* @param {!goog.date.DateLike} dateForTime used to resolve time fields |
| 835 |
* for formatting. |
| 836 |
* @param {goog.i18n.TimeZone=} opt_timeZone This holds current time zone info. |
| 837 |
* @return {string} string representation for the given field. |
| 838 |
* @private |
| 839 |
*/ |
| 840 |
goog.i18n.DateTimeFormat.prototype.formatField_ = function( |
| 841 |
patternStr, date, dateForDate, dateForTime, opt_timeZone) { |
| 842 |
var count = patternStr.length; |
| 843 |
switch (patternStr.charAt(0)) { |
| 844 |
case 'G': |
| 845 |
return this.formatEra_(count, dateForDate); |
| 846 |
case 'y': |
| 847 |
return this.formatYear_(count, dateForDate); |
| 848 |
case 'M': |
| 849 |
return this.formatMonth_(count, dateForDate); |
| 850 |
case 'k': |
| 851 |
return this.format24Hours_(count, dateForTime); |
| 852 |
case 'S': |
| 853 |
return this.formatFractionalSeconds_(count, dateForTime); |
| 854 |
case 'E': |
| 855 |
return this.formatDayOfWeek_(count, dateForDate); |
| 856 |
case 'a': |
| 857 |
return this.formatAmPm_(count, dateForTime); |
| 858 |
case 'h': |
| 859 |
return this.format1To12Hours_(count, dateForTime); |
| 860 |
case 'K': |
| 861 |
return this.format0To11Hours_(count, dateForTime); |
| 862 |
case 'H': |
| 863 |
return this.format0To23Hours_(count, dateForTime); |
| 864 |
case 'c': |
| 865 |
return this.formatStandaloneDay_(count, dateForDate); |
| 866 |
case 'L': |
| 867 |
return this.formatStandaloneMonth_(count, dateForDate); |
| 868 |
case 'Q': |
| 869 |
return this.formatQuarter_(count, dateForDate); |
| 870 |
case 'd': |
| 871 |
return this.formatDate_(count, dateForDate); |
| 872 |
case 'm': |
| 873 |
return this.formatMinutes_(count, dateForTime); |
| 874 |
case 's': |
| 875 |
return this.formatSeconds_(count, dateForTime); |
| 876 |
case 'v': |
| 877 |
return this.formatTimeZoneId_(date, opt_timeZone); |
| 878 |
case 'V': |
| 879 |
return this.formatTimeZoneLocationId_(count, date, opt_timeZone); |
| 880 |
case 'w': |
| 881 |
return this.formatWeekOfYear_(count, dateForTime); |
| 882 |
case 'z': |
| 883 |
return this.formatTimeZone_(count, date, opt_timeZone); |
| 884 |
case 'Z': |
| 885 |
return this.formatTimeZoneRFC_(count, date, opt_timeZone); |
| 886 |
default: |
| 887 |
return ''; |
| 888 |
} |
| 889 |
}; |