analytics/webcontent/dojo17/dojox/date/hebrew/locale.js

define("dojox/date/hebrew/locale", ["dojo/main", "dojo/date", "dojo/i18n", "dojo/regexp", "dojo/string", "./Date", "./numerals", "dojo/i18n!dojo/cldr/nls/hebrew"],
	function(dojo, dd, i18n, regexp, string, hebrewDate, numerals){

	dojo.getObject("date.hebrew.locale", true, dojox);
	dojo.experimental("dojox.date.hebrew.locale");

	//Load the bundles containing localization information for
	// names and formats
	dojo.requireLocalization("dojo.cldr", "hebrew");

	// Format a pattern without literals
	function formatPattern(dateObject, bundle, locale, fullYear,  pattern){

		return pattern.replace(/([a-z])\1*/ig, function(match){
			var s, pad;
			var c = match.charAt(0);
			var l = match.length;
			var widthList = ["abbr", "wide", "narrow"];
			
			switch(c){
				case 'y':
					if(locale.match(/^he(?:-.+)?$/)){
						s = numerals.getYearHebrewLetters(dateObject.getFullYear());
					}else{
						s = String(dateObject.getFullYear());
					}
					break;
				case 'M':
					var m = dateObject.getMonth();
					if(l<3){
						if(!dateObject.isLeapYear(dateObject.getFullYear()) && m>5){m--;}
						if(locale.match(/^he(?:-.+)?$/)){
							s = numerals.getMonthHebrewLetters(m);
						}else{
							s = m+1; pad = true;
						}
					}else{
						var monthNames = dojox.date.hebrew.locale.getNames('months',widthList[l-3], 'format', locale, dateObject);
						s = monthNames[m];
					}
					break;
				case 'd':
					if(locale.match(/^he(?:-.+)?$/)){
						s =  dateObject.getDateLocalized(locale);
					}else{
						s = dateObject.getDate(); pad = true;
					}
					break;
				case 'E':
					var d = dateObject.getDay();
					if(l<3){
						s = d+1; pad = true;
					}else{
						var propD = ["days", "format", widthList[l-3]].join("-");
						s = bundle[propD][d];
					}
					break;
				case 'a':
					var timePeriod = (dateObject.getHours() < 12) ? 'am' : 'pm';
					s = bundle['dayPeriods-format-wide-' + 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)); pad = true;
					break;
				case 'z':
					s = "";
					break;
				default:
					throw new Error("dojox.date.hebrew.locale.formatPattern: invalid pattern char: "+pattern);
			}
			if(pad){ s = string.pad(s, l); }
			return s;
		});
	}
	
	dojox.date.hebrew.locale.format = function(/*hebrew.Date*/dateObject, /*object?*/options){
		// based on and similar to dojo.date.locale.format
		//summary:
		//		Format a Date object as a String, using  settings.
		//
		// description:
		//		Create a string from a hebrew.Date object using a known pattern.
		//		By default, this method formats both date and time from dateObject.
		//		Default formatting lengths is 'short'
		//
		// 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 = options || {};

		var locale = i18n.normalizeLocale(options.locale);
		var formatLength = options.formatLength || 'short';
		var bundle = dojox.date.hebrew.locale._getHebrewBundle(locale);
		var str = [];

		var sauce = dojo.hitch(this, formatPattern, dateObject, bundle, locale, options.fullYear);
		if(options.selector == "year"){
			var year = dateObject.getFullYear();
			return locale.match(/^he(?:-.+)?$/) ?
				numerals.getYearHebrewLetters(year) : year;
		}
		if(options.selector != "time"){
			var datePattern = options.datePattern || bundle["dateFormat-"+formatLength];
			if(datePattern){str.push(_processPattern(datePattern, sauce));}
		}
		if(options.selector != "date"){
			var timePattern = options.timePattern || bundle["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
	};

	dojox.date.hebrew.locale.regexp = function(/*object?*/options){
		//	based on and similar to dojo.date.locale.regexp
		// summary:
		//		Builds the regular needed to parse a hebrew.Date

		return dojox.date.hebrew.locale._parseInfo(options).regexp; // String
	};

	dojox.date.hebrew.locale._parseInfo = function(/*oblect?*/options){
	/* based on and similar to dojo.date.locale._parseInfo */

		options = options || {};
		var locale = i18n.normalizeLocale(options.locale);
		var bundle = dojox.date.hebrew.locale._getHebrewBundle(locale);

		var formatLength = options.formatLength || 'short';
		var datePattern = options.datePattern || bundle["dateFormat-" + formatLength];
		var timePattern = options.timePattern || bundle["timeFormat-" + formatLength];

		var pattern;
		if(options.selector == 'date'){
			pattern = datePattern;
		}else if(options.selector == 'time'){
			pattern = timePattern;
		}else{
			pattern = (timePattern === undefined) ? datePattern : datePattern + ' ' + timePattern; //hebrew resource file does not contain time patterns - a bug?
		}

		var tokens = [];
	
		var re = _processPattern(pattern, dojo.hitch(this, _buildDateTimeRE, tokens, bundle, options));
		return {regexp: re, tokens: tokens, bundle: bundle};
	};

	dojox.date.hebrew.locale.parse = function(/*String*/value, /*Object?*/options){
			// based on and similar to dojo.date.locale.parse
			// summary: This function parse string date value according to options
			// example:
			// |		var dateHebrew = dojox.date.hebrew.locale.parse('11/10/5740', {datePattern:'dd/MM/yy', selector:'date'});
			// |		in Hebrew locale string for parsing contains Hebrew Numerals
			// |
			// |  options = {datePattern:'dd MMMM yy', selector:'date'};
			// |
			// |   y - year
			// |   M, MM  - short month
			// |  MMM, MMMM - long month
			// |  d - date
			// |  a - am, pm
			// |   E, EE, EEE, EEEE  - week day
			// |
			// |    h, H, k, K, m, s, S,  -  time format
		
		value =  value.replace(/[\u200E\u200F\u202A-\u202E]/g, ""); //remove special chars

		if(!options){options={};}
		var info = dojox.date.hebrew.locale._parseInfo(options);
	
		var tokens = info.tokens, bundle = info.bundle;
		var re = new RegExp("^" + info.regexp + "$");
	
		var match = re.exec(value);

		var locale = i18n.normalizeLocale(options.locale);

		if(!match){ return null; } // null
	
		var date, date1;
	
		//var result = [1970,0,1,0,0,0,0]; //
		var result = [5730,3,23,0,0,0,0];  // hebrew date for [1970,0,1,0,0,0,0] used in gregorian locale
		var amPm = "";
		var mLength = 0;
		var widthList = ["abbr", "wide", "narrow"];
		var valid = dojo.every(match, function(v, i){
			if(!i){return true;}
			var token=tokens[i-1];
			var l=token.length;
			switch(token.charAt(0)){
				case 'y':
					if(locale.match(/^he(?:-.+)?$/)){
						result[0] = numerals.parseYearHebrewLetters(v);
					}else{
						result[0] = Number(v);
					}
					break;
				case 'M':
					//if  it is short format, month is one letter or two letter with "geresh"
					if(l>2){
						//we do not know here if the year is leap or not
						var months = dojox.date.hebrew.locale.getNames('months', widthList[l-3], 'format', locale, new hebrewDate(5769, 1, 1)),
							leapmonths = dojox.date.hebrew.locale.getNames('months', widthList[l-3], 'format', locale, new hebrewDate(5768, 1, 1));
						if(!options.strict){
							//Tolerate abbreviating period in month part
							//Case-insensitive comparison
							v = v.replace(".","").toLowerCase();
							months = dojo.map(months, function(s){ return s ? s.replace(".","").toLowerCase() : s; } );
							leapmonths = dojo.map(leapmonths, function(s){ return s ? s.replace(".","").toLowerCase() : s; } );
						}
						var monthName = v;
						v = dojo.indexOf(months, monthName);
						if(v == -1){
							v = dojo.indexOf(leapmonths, monthName);
							if(v == -1){
								//console.debug("dojox.date.hebrew.locale.parse: Could not parse month name:  second   " + v +"'.");
								return false;
							}
						}
						mLength = l;
					}else{
						if(locale.match(/^he(?:-.+)?$/)){
							v = numerals.parseMonthHebrewLetters(v);
						}else{
							v--;
						}
					}
					result[1] = Number(v);
					break;
				case 'D':
					result[1] = 0;
					// fallthrough...
				case 'd':
					if(locale.match(/^he(?:-.+)?$/)){
						result[2] = numerals.parseDayHebrewLetters(v);
					}else{
						result[2] = Number(v);
					}
					break;
				case 'a': //am/pm
					var am = options.am || bundle['dayPeriods-format-wide-am'],
						pm = options.pm || bundle['dayPeriods-format-wide-pm'];
					if(!options.strict){
						var period = /\./g;
						v = v.replace(period,'').toLowerCase();
						am = am.replace(period,'').toLowerCase();
						pm = pm.replace(period,'').toLowerCase();
					}
					if(options.strict && v != am && v != pm){
						return false;
					}

					// we might not have seen the hours field yet, so store the state and apply hour change later
					amPm = (v == pm) ? 'p' : (v == am) ? 'a' : '';
					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)
					//in the 12-hour case, adjusting for am/pm requires the 'a' part
					//which could come before or after the hour, so we will adjust later
					result[3] = Number(v);
					break;
				case 'm': //minutes
					result[4] = Number(v);
					break;
				case 's': //seconds
					result[5] = Number(v);
					break;
				case 'S': //milliseconds
					result[6] = Number(v);
			}
			return true;
		});

		var hours = +result[3];
		if(amPm === 'p' && hours < 12){
			result[3] = hours + 12; //e.g., 3pm -> 15
		}else if(amPm === 'a' && hours == 12){
			result[3] = 0; //12am -> 0
		}
		var dateObject = new hebrewDate(result[0], result[1], result[2], result[3], result[4], result[5], result[6]); // hebrew.Date
		//for non leap year, the index of the short month start from adar should be increased by 1
		if(mLength < 3 && result[1] >= 5 && !dateObject.isLeapYear(dateObject.getFullYear())){
			dateObject.setMonth(result[1]+1);
		}
		return dateObject; // hebrew.Date
	};


	function _processPattern(pattern, applyPattern, applyLiteral, applyAll){
		//summary: 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 = pattern.charAt(0) == "'";

		dojo.forEach(chunks, function(chunk, i){
			if(!chunk){
				chunks[i]='';
			}else{
				chunks[i]=(literal ? applyLiteral : applyPattern)(chunk);
				literal = !literal;
			}
		});
		return applyAll(chunks.join(''));
	}

	function _buildDateTimeRE  (tokens, bundle, options, pattern){
			// based on and similar to dojo.date.locale._buildDateTimeRE
			//
	
		pattern = regexp.escapeString(pattern);
		var locale = i18n.normalizeLocale(options.locale);
	
		return pattern.replace(/([a-z])\1*/ig, function(match){

				// Build a simple regexp.  Avoid captures, which would ruin the tokens list
				var s;
				var c = match.charAt(0);
				var l = match.length;
				var p2 = '', p3 = '';
				if(options.strict){
					if(l > 1){ p2 = '0' + '{'+(l-1)+'}'; }
					if(l > 2){ p3 = '0' + '{'+(l-2)+'}'; }
				}else{
					p2 = '0?'; p3 = '0{0,2}';
				}
				switch(c){
					case 'y':
						s = '\\S+';
						break;
					case 'M':
						if(locale.match('^he(?:-.+)?$')){
							s = (l>2) ? '\\S+ ?\\S+' : '\\S{1,4}';
						}else{
							s = (l>2) ?  '\\S+ ?\\S+' : p2+'[1-9]|1[0-2]';
						}
						break;
					case 'd':
						if(locale.match('^he(?:-.+)?$')){
							s = '\\S[\'\"\'\u05F3]{1,2}\\S?';
						}else{
							s = '[12]\\d|'+p2+'[1-9]|30';
						}
						break;
					case 'E':
						if(locale.match('^he(?:-.+)?$')){
							s = (l>3) ? '\\S+ ?\\S+' : '\\S';
						}else{
							s = '\\S+';
						}
						break;
					case 'h': //hour (1-12)
						s = p2+'[1-9]|1[0-2]';
						break;
					case 'k': //hour (0-11)
						s = p2+'\\d|1[01]';
						break;
					case 'H': //hour (0-23)
						s = p2+'\\d|1\\d|2[0-3]';
						break;
					case 'K': //hour (1-24)
						s = p2+'[1-9]|1\\d|2[0-4]';
						break;
					case 'm':
					case 's':
						s = p2+'\\d|[0-5]\\d';
						break;
					case 'S':
						s = '\\d{'+l+'}';
						break;
					case 'a':
						var am = options.am || bundle['dayPeriods-format-wide-am'],
							pm = options.pm || bundle['dayPeriods-format-wide-pm'];
						if(options.strict){
							s = am + '|' + pm;
						}else{
							s = am + '|' + pm;
							if(am != am.toLowerCase()){ s += '|' + am.toLowerCase(); }
							if(pm != pm.toLowerCase()){ s += '|' + pm.toLowerCase(); }
						}
						break;
					default:
						s = ".*";
				}
				if(tokens){ tokens.push(match); }
				return "(" + s + ")"; // add capture
			}).replace(/[\xa0 ]/g, "[\\s\\xa0]"); // normalize whitespace.  Need explicit handling of \xa0 for IE. */
	}

	var _customFormats = [];
	dojox.date.hebrew.locale.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.cldr: `dateFormat-xxxx` / `timeFormat-xxxx`
		//		The pattern string should match the format used by the CLDR.
		//		See dojo.date.locale.format() for details.
		//		The resources must be loaded by dojo.requireLocalization() prior to use

		_customFormats.push({pkg:packageName,name:bundleName});
	};

	dojox.date.hebrew.locale._getHebrewBundle = function(/*String*/locale){
		var hebrew = {};
		dojo.forEach(_customFormats, function(desc){
			var bundle = i18n.getLocalization(desc.pkg, desc.name, locale);
			hebrew = dojo.mixin(hebrew, bundle);
		}, this);
		return hebrew; /*Object*/
	};

	dojox.date.hebrew.locale.addCustomFormats("dojo.cldr","hebrew");

	dojox.date.hebrew.locale.getNames = function(/*String*/item, /*String*/type, /*String?*/context, /*String?*/locale, /*dojox.date.hebrew.Date?*/date){
		// summary:
		//		Used to get localized strings from dojo.cldr 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
		// date:
		//	required for item=months to determine leap month name
		//
		// using  var monthNames = dojox.date.hebrew.locale.getNames('months', 'wide', 'format', 'he', new hebrewDate(5768, 2, 12));

		var label,
			lookup = dojox.date.hebrew.locale._getHebrewBundle(locale),
			props = [item, context, type];
		if(context == 'standAlone'){
			var key = props.join('-');
			label = lookup[key];
			// Fall back to 'format' flavor of name
			if(label[0] == 1){ label = undefined; } // kludge, in the absence of real aliasing support in dojo.cldr
		}
		props[1] = 'format';
	
		// return by copy so changes won't be made accidentally to the in-memory model
		var result = (label || lookup[props.join('-')]).concat();

		if(item == "months"){
			if(date.isLeapYear(date.getFullYear())){
				// Adar I (6th position in the array) will be used.
				// Substitute the leap month Adar II for the regular Adar (7th position)
				props.push("leap");
				result[6] = lookup[props.join('-')];
			}else{
				// Remove Adar I but leave an empty position in the array
				delete result[5];
			}
		}

		return result; /*Array*/
	};

	return dojox.date.hebrew.locale;
});