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 formatting & Parsing,
17
 * County and language name, TimeZone list.
18
 * @suppress {deprecated} Use goog.i18n instead.
19
 */
20

21

22
/**
23
 * Namespace for locale related functions.
24
 */
25
goog.provide('goog.locale');
26

27
goog.require('goog.locale.nativeNameConstants');
28

29

30
/**
31
 * Set current locale to the specified one.
32
 * @param {string} localeName Locale name string. We are following the usage
33
 *     in CLDR, but can make a few compromise for existing name compatibility.
34
 */
35
goog.locale.setLocale = function(localeName) {
36
  // it is common to see people use '-' as locale part separator, normalize it.
37
  localeName = localeName.replace(/-/g, '_');
38
  goog.locale.activeLocale_ = localeName;
39
};
40

41

42
/**
43
 * Retrieve the current locale
44
 * @return {string} Current locale name string.
45
 * @deprecated Use goog.LOCALE and goog.i18n instead.
46
 */
47
goog.locale.getLocale = function() {
48
  if (!goog.locale.activeLocale_) {
49
    goog.locale.activeLocale_ = 'en';
50
  }
51
  return goog.locale.activeLocale_;
52
};
53

54

55
// Couple of constants to represent predefined Date/Time format type.
56
/**
57
 * Enum of resources that can be registered.
58
 * @enum {string}
59
 */
60
goog.locale.Resource = {
61
  DATE_TIME_CONSTANTS: 'DateTimeConstants',
62
  NUMBER_FORMAT_CONSTANTS: 'NumberFormatConstants',
63
  TIME_ZONE_CONSTANTS: 'TimeZoneConstants',
64
  LOCAL_NAME_CONSTANTS: 'LocaleNameConstants',
65

66
  TIME_ZONE_SELECTED_IDS: 'TimeZoneSelectedIds',
67
  TIME_ZONE_SELECTED_SHORT_NAMES: 'TimeZoneSelectedShortNames',
68
  TIME_ZONE_SELECTED_LONG_NAMES: 'TimeZoneSelectedLongNames',
69
  TIME_ZONE_ALL_LONG_NAMES: 'TimeZoneAllLongNames'
70
};
71

72

73
// BCP 47 language code:
74
//
75
// LanguageCode := LanguageSubtag
76
//                ("-" ScriptSubtag)?
77
//                ("-" RegionSubtag)?
78
//                ("-" VariantSubtag)?
79
//                ("@" Keyword "=" Value ("," Keyword "=" Value)* )?
80
//
81
// e.g. en-Latn-GB
82
//
83
// NOTICE:
84
// No special format checking is performed. If you pass a none valid
85
// language code as parameter to the following functions,
86
// you might get an unexpected result.
87

88

89
/**
90
 * Returns the language-subtag of the given language code.
91
 *
92
 * @param {string} languageCode Language code to extract language subtag from.
93
 * @return {string} Language subtag (in lowercase).
94
 */
95
goog.locale.getLanguageSubTag = function(languageCode) {
96
  var result = languageCode.match(/^\w{2,3}([-_]|$)/);
97
  return result ? result[0].replace(/[_-]/g, '') : '';
98
};
99

100

101
/**
102
 * Returns the region-sub-tag of the given language code.
103
 *
104
 * @param {string} languageCode Language code to extract region subtag from.
105
 * @return {string} Region sub-tag (in uppercase).
106
 */
107
goog.locale.getRegionSubTag = function(languageCode) {
108
  var result = languageCode.match(/[-_]([a-zA-Z]{2}|\d{3})([-_]|$)/);
109
  return result ? result[0].replace(/[_-]/g, '') : '';
110
};
111

112

113
/**
114
 * Returns the script subtag of the locale with the first alphabet in uppercase
115
 * and the rest 3 characters in lower case.
116
 *
117
 * @param {string} languageCode Language Code to extract script subtag from.
118
 * @return {string} Script subtag.
119
 */
120
goog.locale.getScriptSubTag = function(languageCode) {
121
  var result = languageCode.split(/[-_]/g);
122
  return result.length > 1 && result[1].match(/^[a-zA-Z]{4}$/) ? result[1] : '';
123
};
124

125

126
/**
127
 * Returns the variant-sub-tag of the given language code.
128
 *
129
 * @param {string} languageCode Language code to extract variant subtag from.
130
 * @return {string} Variant sub-tag.
131
 */
132
goog.locale.getVariantSubTag = function(languageCode) {
133
  var result = languageCode.match(/[-_]([a-z]{2,})/);
134
  return result ? result[1] : '';
135
};
136

137

138
/**
139
 * Returns the country name of the provided language code in its native
140
 * language.
141
 *
142
 * This method depends on goog.locale.nativeNameConstants available from
143
 * nativenameconstants.js. User of this method has to add dependency to this.
144
 *
145
 * @param {string} countryCode Code to lookup the country name for.
146
 *
147
 * @return {string} Country name for the provided language code.
148
 */
149
goog.locale.getNativeCountryName = function(countryCode) {
150
  var key = goog.locale.getLanguageSubTag(countryCode) + '_' +
151
      goog.locale.getRegionSubTag(countryCode);
152
  return key in goog.locale.nativeNameConstants['COUNTRY'] ?
153
      goog.locale.nativeNameConstants['COUNTRY'][key] :
154
      countryCode;
155
};
156

157

158
/**
159
 * Returns the localized country name for the provided language code in the
160
 * current or provided locale symbols set.
161
 *
162
 * This method depends on `goog.locale.LocaleNameConstants__<locale>` available
163
 * from http://go/js_locale_data. User of this method has to add dependency to
164
 * this.
165
 *
166
 * @param {string} languageCode Language code to lookup the country name for.
167
 * @param {Object=} opt_localeSymbols If omitted the current locale symbol
168
 *     set is used.
169
 *
170
 * @return {string} Localized country name.
171
 */
172
goog.locale.getLocalizedCountryName = function(
173
    languageCode, opt_localeSymbols) {
174
  var code = goog.locale.getRegionSubTag(languageCode);
175
  var name =
176
      goog.locale.getLocalizedRegionNameFromRegionCode(code, opt_localeSymbols);
177
  return name == code ? languageCode : name;
178
};
179

180
/**
181
 * Returns the localized country name for the provided language code in the
182
 * current or provided locale symbols set.
183
 *
184
 * This method depends on `goog.locale.LocaleNameConstants__<locale>` available
185
 * from http://go/js_locale_data. User of this method has to add dependency to
186
 * this.
187
 *
188
 * @param {string} regionCode Two character country code or three digit region
189
 *      code to look up the country name for.
190
 * @param {?Object=} opt_localeSymbols If omitted the current locale symbol
191
 *     set is used.
192
 *
193
 * @return {string} Localized region name.
194
 */
195
goog.locale.getLocalizedRegionNameFromRegionCode = function(
196
    regionCode, opt_localeSymbols) {
197
  if (!opt_localeSymbols) {
198
    opt_localeSymbols =
199
        goog.locale.getResource('LocaleNameConstants', goog.locale.getLocale());
200
  }
201
  return regionCode in opt_localeSymbols['COUNTRY'] ?
202
      opt_localeSymbols['COUNTRY'][regionCode] :
203
      regionCode;
204
};
205

206
/**
207
 * Returns the language name of the provided language code in its native
208
 * language.
209
 *
210
 * This method depends on goog.locale.nativeNameConstants available from
211
 * nativenameconstants.js. User of this method has to add dependency to this.
212
 *
213
 * @param {string} languageCode Language code to lookup the language name for.
214
 *
215
 * @return {string} Language name for the provided language code.
216
 */
217
goog.locale.getNativeLanguageName = function(languageCode) {
218
  if (languageCode in goog.locale.nativeNameConstants['LANGUAGE'])
219
    return goog.locale.nativeNameConstants['LANGUAGE'][languageCode];
220
  var code = goog.locale.getLanguageSubTag(languageCode);
221
  return code in goog.locale.nativeNameConstants['LANGUAGE'] ?
222
      goog.locale.nativeNameConstants['LANGUAGE'][code] :
223
      languageCode;
224
};
225

226

227
/**
228
 * Returns the localized language name for the provided language code in
229
 * the current or provided locale symbols set.
230
 *
231
 * This method depends on `goog.locale.LocaleNameConstants__<locale>` available
232
 * from http://go/js_locale_data. User of this method has to add dependency to
233
 * this.
234
 *
235
 * @param {string} languageCode Language code to lookup the language name for.
236
 * @param {Object=} opt_localeSymbols locale symbol set if given.
237
 *
238
 * @return {string} Localized language name of the provided language code.
239
 */
240
goog.locale.getLocalizedLanguageName = function(
241
    languageCode, opt_localeSymbols) {
242
  if (!opt_localeSymbols) {
243
    opt_localeSymbols =
244
        goog.locale.getResource('LocaleNameConstants', goog.locale.getLocale());
245
  }
246
  if (languageCode in opt_localeSymbols['LANGUAGE'])
247
    return opt_localeSymbols['LANGUAGE'][languageCode];
248
  var code = goog.locale.getLanguageSubTag(languageCode);
249
  return code in opt_localeSymbols['LANGUAGE'] ?
250
      opt_localeSymbols['LANGUAGE'][code] :
251
      languageCode;
252
};
253

254

255
/**
256
 * Register a resource object for certain locale.
257
 * @param {Object} dataObj The resource object being registered.
258
 * @param {goog.locale.Resource|string} resourceName String that represents
259
 *     the type of resource.
260
 * @param {string} localeName Locale ID.
261
 */
262
goog.locale.registerResource = function(dataObj, resourceName, localeName) {
263
  if (!goog.locale.resourceRegistry_[resourceName]) {
264
    goog.locale.resourceRegistry_[resourceName] = {};
265
  }
266
  goog.locale.resourceRegistry_[resourceName][localeName] = dataObj;
267
  // the first registered locale becomes active one. Usually there will be
268
  // only one locale per js binary bundle.
269
  if (!goog.locale.activeLocale_) {
270
    goog.locale.activeLocale_ = localeName;
271
  }
272
};
273

274

275
/**
276
 * Returns true if the required resource has already been registered.
277
 * @param {goog.locale.Resource|string} resourceName String that represents
278
 *     the type of resource.
279
 * @param {string} localeName Locale ID.
280
 * @return {boolean} Whether the required resource has already been registered.
281
 */
282
goog.locale.isResourceRegistered = function(resourceName, localeName) {
283
  return resourceName in goog.locale.resourceRegistry_ &&
284
      localeName in goog.locale.resourceRegistry_[resourceName];
285
};
286

287

288
/**
289
 * This object maps (resourceName, localeName) to a resourceObj.
290
 * @type {Object}
291
 * @private
292
 */
293
goog.locale.resourceRegistry_ = {};
294

295

296
/**
297
 * Registers the timezone constants object for a given locale name.
298
 * @param {Object} dataObj The resource object.
299
 * @param {string} localeName Locale ID.
300
 * @deprecated Use goog.i18n.TimeZone, no longer need this.
301
 */
302
goog.locale.registerTimeZoneConstants = function(dataObj, localeName) {
303
  goog.locale.registerResource(
304
      dataObj, goog.locale.Resource.TIME_ZONE_CONSTANTS, localeName);
305
};
306

307

308
/**
309
 * Registers the LocaleNameConstants constants object for a given locale name.
310
 * @param {Object} dataObj The resource object.
311
 * @param {string} localeName Locale ID.
312
 */
313
goog.locale.registerLocaleNameConstants = function(dataObj, localeName) {
314
  goog.locale.registerResource(
315
      dataObj, goog.locale.Resource.LOCAL_NAME_CONSTANTS, localeName);
316
};
317

318

319
/**
320
 * Registers the TimeZoneSelectedIds constants object for a given locale name.
321
 * @param {Object} dataObj The resource object.
322
 * @param {string} localeName Locale ID.
323
 */
324
goog.locale.registerTimeZoneSelectedIds = function(dataObj, localeName) {
325
  goog.locale.registerResource(
326
      dataObj, goog.locale.Resource.TIME_ZONE_SELECTED_IDS, localeName);
327
};
328

329

330
/**
331
 * Registers the TimeZoneSelectedShortNames constants object for a given
332
 *     locale name.
333
 * @param {Object} dataObj The resource object.
334
 * @param {string} localeName Locale ID.
335
 */
336
goog.locale.registerTimeZoneSelectedShortNames = function(dataObj, localeName) {
337
  goog.locale.registerResource(
338
      dataObj, goog.locale.Resource.TIME_ZONE_SELECTED_SHORT_NAMES, localeName);
339
};
340

341

342
/**
343
 * Registers the TimeZoneSelectedLongNames constants object for a given locale
344
 *     name.
345
 * @param {Object} dataObj The resource object.
346
 * @param {string} localeName Locale ID.
347
 */
348
goog.locale.registerTimeZoneSelectedLongNames = function(dataObj, localeName) {
349
  goog.locale.registerResource(
350
      dataObj, goog.locale.Resource.TIME_ZONE_SELECTED_LONG_NAMES, localeName);
351
};
352

353

354
/**
355
 * Registers the TimeZoneAllLongNames constants object for a given locale name.
356
 * @param {Object} dataObj The resource object.
357
 * @param {string} localeName Locale ID.
358
 */
359
goog.locale.registerTimeZoneAllLongNames = function(dataObj, localeName) {
360
  goog.locale.registerResource(
361
      dataObj, goog.locale.Resource.TIME_ZONE_ALL_LONG_NAMES, localeName);
362
};
363

364

365
/**
366
 * Retrieve specified resource for certain locale.
367
 * @param {string} resourceName String that represents the type of resource.
368
 * @param {string=} opt_locale Locale ID, if not given, current locale
369
 *     will be assumed.
370
 * @return {Object|undefined} The resource object that hold all the resource
371
 *     data, or undefined if not available.
372
 */
373
goog.locale.getResource = function(resourceName, opt_locale) {
374
  var locale = opt_locale ? opt_locale : goog.locale.getLocale();
375

376
  if (!(resourceName in goog.locale.resourceRegistry_)) {
377
    return undefined;
378
  }
379
  return goog.locale.resourceRegistry_[resourceName][locale];
380
};
381

382

383
/**
384
 * Retrieve specified resource for certain locale with fallback. For example,
385
 * request of 'zh_CN' will be resolved in following order: zh_CN, zh, en.
386
 * If none of the above succeeds, of if the resource as indicated by
387
 * resourceName does not exist at all, undefined will be returned.
388
 *
389
 * @param {string} resourceName String that represents the type of resource.
390
 * @param {string=} opt_locale locale ID, if not given, current locale
391
 *     will be assumed.
392
 * @return {Object|undefined} The resource object for desired locale.
393
 */
394
goog.locale.getResourceWithFallback = function(resourceName, opt_locale) {
395
  var locale = opt_locale ? opt_locale : goog.locale.getLocale();
396

397
  if (!(resourceName in goog.locale.resourceRegistry_)) {
398
    return undefined;
399
  }
400

401
  if (locale in goog.locale.resourceRegistry_[resourceName]) {
402
    return goog.locale.resourceRegistry_[resourceName][locale];
403
  }
404

405
  // if locale has multiple parts (2 atmost in reality), fallback to base part.
406
  var locale_parts = locale.split('_');
407
  if (locale_parts.length > 1 &&
408
      locale_parts[0] in goog.locale.resourceRegistry_[resourceName]) {
409
    return goog.locale.resourceRegistry_[resourceName][locale_parts[0]];
410
  }
411

412
  // otherwise, fallback to 'en'
413
  return goog.locale.resourceRegistry_[resourceName]['en'];
414
};
415

416

417
// Export global functions that are used by the date time constants files.
418
// See http://go/js_locale_data
419
var registerLocalNameConstants = goog.locale.registerLocaleNameConstants;
420

421
var registerTimeZoneSelectedIds = goog.locale.registerTimeZoneSelectedIds;
422
var registerTimeZoneSelectedShortNames =
423
    goog.locale.registerTimeZoneSelectedShortNames;
424
var registerTimeZoneSelectedLongNames =
425
    goog.locale.registerTimeZoneSelectedLongNames;
426
var registerTimeZoneAllLongNames = goog.locale.registerTimeZoneAllLongNames;
427

428