1
// Copyright 2009 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
/**
17
 * @fileoverview A utility to get better currency format pattern.
18
 *
19
 * This module implements a new currency format representation model. It
20
 * provides 3 currency representation forms: global, portable and local. Local
21
 * format is the most popular format people use to represent currency in its
22
 * circulating country without worrying about how it should be distinguished
23
 * from other currencies.  Global format is a formal representation in context
24
 * of multiple currencies in same page, it is ISO 4217 currency code. Portable
25
 * format is a compromise between global and local. It looks similar to how
26
 * people would like to see how their currency is being represented in other
27
 * media. While at the same time, it should be distinguishable to world's
28
 * popular currencies (like USD, EUR) and currencies somewhat relevant in the
29
 * area (like CNY in HK, though native currency is HKD). There is no guarantee
30
 * of uniqueness.
31
 *
32
 */
33

34

35
goog.provide('goog.i18n.currency');
36
goog.provide('goog.i18n.currency.CurrencyInfo');
37
goog.provide('goog.i18n.currency.CurrencyInfoTier2');
38

39

40
/**
41
 * The mask of precision field.
42
 * @private
43
 */
44
goog.i18n.currency.PRECISION_MASK_ = 0x07;
45

46

47
/**
48
 * Whether the currency sign should be positioned after the number.
49
 * @private
50
 */
51
goog.i18n.currency.POSITION_FLAG_ = 0x10;
52

53

54
/**
55
 * Whether a space should be inserted between the number and currency sign.
56
 * @private
57
 */
58
goog.i18n.currency.SPACE_FLAG_ = 0x20;
59

60

61
/**
62
 * Whether tier2 was enabled already by calling addTier2Support().
63
 * @private
64
 */
65
goog.i18n.currency.tier2Enabled_ = false;
66

67

68
/**
69
 * Tests if currency is available.
70
 *
71
 * Note: If the currency is not available it might be in the tier2 currency set:
72
 * {@link goog.i18n.currency.CurrencyInfoTier2}. If that is the case call
73
 * {@link goog.i18n.currency.addTier2Support} before calling any other function
74
 * in this namespace.
75
 *
76
 * @param {string} currencyCode Currency code to tested.
77
 * @return {boolean} If the currency is available.
78
 */
79
goog.i18n.currency.isAvailable = function(currencyCode) {
80
  return currencyCode in goog.i18n.currency.CurrencyInfo;
81
};
82

83
/**
84
 * This function will add tier2 currency support. Be default, only tier1
85
 * (most popular currencies) are supported. If an application really needs
86
 * to support some of the rarely used currencies, it should call this function
87
 * before any other functions in this namespace.
88
 */
89
goog.i18n.currency.addTier2Support = function() {
90
  // Protection from executing this these again and again.
91
  if (!goog.i18n.currency.tier2Enabled_) {
92
    for (var key in goog.i18n.currency.CurrencyInfoTier2) {
93
      goog.i18n.currency.CurrencyInfo[key] =
94
          goog.i18n.currency.CurrencyInfoTier2[key];
95
    }
96
    goog.i18n.currency.tier2Enabled_ = true;
97
  }
98
};
99

100

101
/**
102
 * Deprecated.
103
 * Global currency pattern always uses ISO-4217 currency code as prefix. Local
104
 * currency sign is added if it is different from currency code. Each currency
105
 * is unique in this form. The negative side is that ISO code looks weird in
106
 * some countries as people normally do not use it. Local currency sign
107
 * alleviates the problem, but also makes it a little verbose.
108
 *
109
 * @param {string} currencyCode ISO-4217 3-letter currency code.
110
 * @return {string} Global currency pattern string for given currency.
111
 * @deprecated Format numbers using {@link goog.i18n.NumberFormat} with
112
 *   {@link goog.i18n.NumberFormat.Format.CURRENCY} and
113
 *   {@link goog.i18n.NumberFormat.CurrencyStyle.GLOBAL}
114
 */
115
goog.i18n.currency.getGlobalCurrencyPattern = function(currencyCode) {
116
  var info = goog.i18n.currency.CurrencyInfo[currencyCode];
117
  var patternNum = info[0];
118
  if (currencyCode == info[1]) {
119
    return goog.i18n.currency.getCurrencyPattern_(patternNum, info[1]);
120
  }
121
  return currencyCode + ' ' +
122
      goog.i18n.currency.getCurrencyPattern_(patternNum, info[1]);
123
};
124

125

126
/**
127
 * Return global currency sign string for those applications
128
 * that want to handle currency sign themselves.
129
 *
130
 * @param {string} currencyCode ISO-4217 3-letter currency code.
131
 * @return {string} Global currency sign for given currency.
132
 */
133
goog.i18n.currency.getGlobalCurrencySign = function(currencyCode) {
134
  var info = goog.i18n.currency.CurrencyInfo[currencyCode];
135
  return (currencyCode == info[1]) ? currencyCode :
136
                                     currencyCode + ' ' + info[1];
137
};
138

139

140
/**
141
 * Deprecated.
142
 * Local currency pattern is the most frequently used pattern in currency's
143
 * native region. It does not care about how it is distinguished from other
144
 * currencies.
145
 *
146
 * @param {string} currencyCode ISO-4217 3-letter currency code.
147
 * @return {string} Local currency pattern string for given currency.
148
 * @deprecated Format numbers using {@link goog.i18n.NumberFormat} with
149
 *   {@link goog.i18n.NumberFormat.Format.CURRENCY} and
150
 *   {@link goog.i18n.NumberFormat.CurrencyStyle.LOCAL}
151
 */
152
goog.i18n.currency.getLocalCurrencyPattern = function(currencyCode) {
153
  var info = goog.i18n.currency.CurrencyInfo[currencyCode];
154
  return goog.i18n.currency.getCurrencyPattern_(info[0], info[1]);
155
};
156

157

158
/**
159
 * Returns local currency sign string for those applications that need to
160
 * handle currency sign separately.
161
 *
162
 * @param {string} currencyCode ISO-4217 3-letter currency code.
163
 * @return {string} Local currency sign for given currency.
164
 */
165
goog.i18n.currency.getLocalCurrencySign = function(currencyCode) {
166
  return goog.i18n.currency.CurrencyInfo[currencyCode][1];
167
};
168

169

170
/**
171
 * Deprecated.
172
 * Portable currency pattern is a compromise between local and global. It is
173
 * not a mere blend or mid-way between the two. Currency sign is chosen so that
174
 * it looks familiar to native users. It also has enough information to
175
 * distinguish itself from other popular currencies in its native region.
176
 * In this pattern, currency sign symbols that has availability problem in
177
 * popular fonts are also avoided.
178
 *
179
 * @param {string} currencyCode ISO-4217 3-letter currency code.
180
 * @return {string} Portable currency pattern string for given currency.
181
 * @deprecated Format numbers using {@link goog.i18n.NumberFormat} with
182
 *   {@link goog.i18n.NumberFormat.Format.CURRENCY} and
183
 *   {@link goog.i18n.NumberFormat.CurrencyStyle.PORTABLE}
184
 */
185
goog.i18n.currency.getPortableCurrencyPattern = function(currencyCode) {
186
  var info = goog.i18n.currency.CurrencyInfo[currencyCode];
187
  return goog.i18n.currency.getCurrencyPattern_(info[0], info[2]);
188
};
189

190

191
/**
192
 * Return portable currency sign string for those applications that need to
193
 * handle currency sign themselves.
194
 *
195
 * @param {string} currencyCode ISO-4217 3-letter currency code.
196
 * @return {string} Portable currency sign for given currency.
197
 */
198
goog.i18n.currency.getPortableCurrencySign = function(currencyCode) {
199
  return goog.i18n.currency.CurrencyInfo[currencyCode][2];
200
};
201

202

203
/**
204
 * This function returns the default currency sign's position. Some applications
205
 * may want to handle currency sign and currency amount separately. This
206
 * function can be used in such situations to correctly position the currency
207
 * sign relative to the amount.
208
 *
209
 * Use {@link goog.i18n.NumberFormat#isCurrencyCodeBeforeValue} for a locale
210
 * aware version of this API (recommended). isPrefixSignPosition() returns the
211
 * default currency sign's position in the currency's default locale (e.g. 'en'
212
 * for 'USD'), but most commonly the position is needed for the locale in which
213
 * the number is going to be displayed. For example, in 'fr' 10.10 USD would be
214
 * displayed as '10,10 $'.
215
 *
216
 * @param {string} currencyCode ISO-4217 3-letter currency code.
217
 * @return {boolean} true if currency should be positioned before amount field.
218
 */
219
goog.i18n.currency.isPrefixSignPosition = function(currencyCode) {
220
  return (goog.i18n.currency.CurrencyInfo[currencyCode][0] &
221
          goog.i18n.currency.POSITION_FLAG_) == 0;
222
};
223

224

225
/**
226
 * This function constructs the currency pattern. Currency sign is provided. The
227
 * pattern information is encoded in patternNum.
228
 *
229
 * @param {number} patternNum Encoded pattern number that has
230
 *     currency pattern information.
231
 * @param {string} sign The currency sign that will be used in pattern.
232
 * @return {string} currency pattern string.
233
 * @private
234
 */
235
goog.i18n.currency.getCurrencyPattern_ = function(patternNum, sign) {
236
  var strParts = ['#,##0'];
237
  var precision = patternNum & goog.i18n.currency.PRECISION_MASK_;
238
  if (precision > 0) {
239
    strParts.push('.');
240
    for (var i = 0; i < precision; i++) {
241
      strParts.push('0');
242
    }
243
  }
244
  if ((patternNum & goog.i18n.currency.POSITION_FLAG_) == 0) {
245
    strParts.unshift(
246
        (patternNum & goog.i18n.currency.SPACE_FLAG_) ? "' " : "'");
247
    strParts.unshift(sign);
248
    strParts.unshift("'");
249
  } else {
250
    strParts.push(
251
        (patternNum & goog.i18n.currency.SPACE_FLAG_) ? " '" : "'", sign, "'");
252
  }
253
  return strParts.join('');
254
};
255

256

257
/**
258
 * Modify currency pattern string by adjusting precision for given currency.
259
 * Standard currency pattern will have 2 digit after decimal point.
260
 * Examples:
261
 *   $#,##0.00 ->  $#,##0    (precision == 0)
262
 *   $#,##0.00 ->  $#,##0.0  (precision == 1)
263
 *   $#,##0.00 ->  $#,##0.000  (precision == 3)
264
 *
265
 * @param {string} pattern currency pattern string.
266
 * @param {string} currencyCode 3-letter currency code.
267
 * @return {string} modified currency pattern string.
268
 */
269
goog.i18n.currency.adjustPrecision = function(pattern, currencyCode) {
270
  var strParts = ['0'];
271
  var info = goog.i18n.currency.CurrencyInfo[currencyCode];
272
  var precision = info[0] & goog.i18n.currency.PRECISION_MASK_;
273
  if (precision > 0) {
274
    strParts.push('.');
275
    for (var i = 0; i < precision; i++) {
276
      strParts.push('0');
277
    }
278
  }
279
  return pattern.replace(/0.00/g, strParts.join(''));
280
};
281

282

283
/**
284
 * Tier 1 currency information.
285
 *
286
 * The first number in the array is a combination of the precision mask and
287
 * other flags. The precision mask indicates how many decimal places to show for
288
 * the currency. Valid values are [0..7]. The position flag indicates whether
289
 * the currency sign should be positioned after the number. Valid values are 0
290
 * (before the number) or 16 (after the number). The space flag indicates
291
 * whether a space should be inserted between the currency sign and number.
292
 * Valid values are 0 (no space) and 32 (space).
293
 *
294
 * The number in the array is calculated by adding together the mask and flag
295
 * values. For example:
296
 *
297
 * 0: no precision (0), currency sign first (0), no space (0)
298
 * 2: two decimals precision (2), currency sign first (0), no space (0)
299
 * 18: two decimals precision (2), currency sign last (16), no space (0)
300
 * 50: two decimals precision (2), currency sign last (16), space (32)
301
 *
302
 * It's not recommended to read this data directly. Format numbers using
303
 * {@link goog.i18n.NumberFormat} with
304
 * {@link goog.i18n.NumberFormat.Format.CURRENCY} instead.
305
 *
306
 * @const {!Object<!Array<?>>}
307
 */
308
goog.i18n.currency.CurrencyInfo = {
309
  'AED': [2, 'dh', '\u062f.\u0625.', 'DH'],
310
  'ALL': [0, 'Lek', 'Lek'],
311
  'AUD': [2, '$', 'AU$'],
312
  'BDT': [2, '\u09F3', 'Tk'],
313
  'BGN': [2, 'lev', 'lev'],
314
  'BRL': [2, 'R$', 'R$'],
315
  'CAD': [2, '$', 'C$'],
316
  'CDF': [2, 'FrCD', 'CDF'],
317
  'CHF': [2, 'CHF', 'CHF'],
318
  'CLP': [0, '$', 'CL$'],
319
  'CNY': [2, '¥', 'RMB¥'],
320
  'COP': [32, '$', 'COL$'],
321
  'CRC': [0, '\u20a1', 'CR\u20a1'],
322
  'CZK': [50, 'K\u010d', 'K\u010d'],
323
  'DKK': [50, 'kr.', 'kr.'],
324
  'DOP': [2, 'RD$', 'RD$'],
325
  'EGP': [2, '£', 'LE'],
326
  'ETB': [2, 'Birr', 'Birr'],
327
  'EUR': [2, '€', '€'],
328
  'GBP': [2, '£', 'GB£'],
329
  'HKD': [2, '$', 'HK$'],
330
  'HRK': [2, 'kn', 'kn'],
331
  'HUF': [34, 'Ft', 'Ft'],
332
  'IDR': [0, 'Rp', 'Rp'],
333
  'ILS': [34, '\u20AA', 'IL\u20AA'],
334
  'INR': [2, '\u20B9', 'Rs'],
335
  'IRR': [0, 'Rial', 'IRR'],
336
  'ISK': [0, 'kr', 'kr'],
337
  'JMD': [2, '$', 'JA$'],
338
  'JPY': [0, '¥', 'JP¥'],
339
  'KRW': [0, '\u20A9', 'KR₩'],
340
  'LKR': [2, 'Rs', 'SLRs'],
341
  'LTL': [2, 'Lt', 'Lt'],
342
  'MNT': [0, '\u20AE', 'MN₮'],
343
  'MVR': [2, 'Rf', 'MVR'],
344
  'MXN': [2, '$', 'Mex$'],
345
  'MYR': [2, 'RM', 'RM'],
346
  'NOK': [50, 'kr', 'NOkr'],
347
  'PAB': [2, 'B/.', 'B/.'],
348
  'PEN': [2, 'S/.', 'S/.'],
349
  'PHP': [2, '\u20B1', 'PHP'],
350
  'PKR': [0, 'Rs', 'PKRs.'],
351
  'PLN': [50, 'z\u0142', 'z\u0142'],
352
  'RON': [2, 'RON', 'RON'],
353
  'RSD': [0, 'din', 'RSD'],
354
  'RUB': [50, '\u20bd', 'RUB'],
355
  'SAR': [2, 'Rial', 'Rial'],
356
  'SEK': [50, 'kr', 'kr'],
357
  'SGD': [2, '$', 'S$'],
358
  'THB': [2, '\u0e3f', 'THB'],
359
  'TRY': [2, 'TL', 'YTL'],
360
  'TWD': [2, 'NT$', 'NT$'],
361
  'TZS': [0, 'TSh', 'TSh'],
362
  'UAH': [2, 'грн.', 'UAH'],
363
  'USD': [2, '$', 'US$'],
364
  'UYU': [2, '$', '$U'],
365
  'VND': [48, '\u20AB', 'VN\u20AB'],
366
  'YER': [0, 'Rial', 'Rial'],
367
  'ZAR': [2, 'R', 'ZAR']
368
};
369

370

371
/**
372
 * Tier 2 currency information.
373
 *
374
 * It's not recommended to read this data directly. Format numbers using
375
 * {@link goog.i18n.NumberFormat} with
376
 * {@link goog.i18n.NumberFormat.Format.CURRENCY} instead.
377
 *
378
 * @const {!Object<!Array<?>>}
379
 */
380
goog.i18n.currency.CurrencyInfoTier2 = {
381
  'AFN': [48, 'Af.', 'AFN'],
382
  'AMD': [32, 'Dram', 'dram'],
383
  'ANG': [2, 'NAf.', 'ANG'],
384
  'AOA': [2, 'Kz', 'Kz'],
385
  'ARS': [34, '$', 'AR$'],
386
  'AWG': [2, 'Afl.', 'Afl.'],
387
  'AZN': [34, '\u20bc', 'AZN'],
388
  'BAM': [2, 'KM', 'KM'],
389
  'BBD': [2, '$', 'Bds$'],
390
  'BHD': [3, 'din', 'din'],
391
  'BIF': [0, 'FBu', 'FBu'],
392
  'BMD': [2, '$', 'BD$'],
393
  'BND': [2, '$', 'B$'],
394
  'BOB': [2, 'Bs', 'Bs'],
395
  'BSD': [2, '$', 'BS$'],
396
  'BTN': [2, 'Nu.', 'Nu.'],
397
  'BWP': [2, 'P', 'pula'],
398
  'BYR': [48, 'p.', 'BYR'],
399
  'BZD': [2, '$', 'BZ$'],
400
  'CUC': [1, '$', 'CUC$'],
401
  'CUP': [2, '$', 'CU$'],
402
  'CVE': [2, 'CVE', 'Esc'],
403
  'DJF': [0, 'Fdj', 'Fdj'],
404
  'DZD': [2, 'din', 'din'],
405
  'ERN': [2, 'Nfk', 'Nfk'],
406
  'FJD': [2, '$', 'FJ$'],
407
  'FKP': [2, '£', 'FK£'],
408
  'GEL': [2, 'GEL', 'GEL'],
409
  'GHS': [2, 'GHS', 'GHS'],
410
  'GIP': [2, '£', 'GI£'],
411
  'GMD': [2, 'GMD', 'GMD'],
412
  'GNF': [0, 'FG', 'FG'],
413
  'GTQ': [2, 'Q', 'GTQ'],
414
  'GYD': [0, '$', 'GY$'],
415
  'HNL': [2, 'L', 'HNL'],
416
  'HTG': [2, 'HTG', 'HTG'],
417
  'IQD': [0, 'din', 'IQD'],
418
  'JOD': [3, 'din', 'JOD'],
419
  'KES': [2, 'Ksh', 'Ksh'],
420
  'KGS': [2, 'KGS', 'KGS'],
421
  'KHR': [2, 'Riel', 'KHR'],
422
  'KMF': [0, 'CF', 'KMF'],
423
  'KPW': [0, '\u20A9KP', 'KPW'],
424
  'KWD': [3, 'din', 'KWD'],
425
  'KYD': [2, '$', 'KY$'],
426
  'KZT': [2, '\u20B8', 'KZT'],
427
  'LAK': [0, '\u20AD', '\u20AD'],
428
  'LBP': [0, 'L£', 'LBP'],
429
  'LRD': [2, '$', 'L$'],
430
  'LSL': [2, 'LSL', 'LSL'],
431
  'LYD': [3, 'din', 'LD'],
432
  'MAD': [2, 'dh', 'MAD'],
433
  'MDL': [2, 'MDL', 'MDL'],
434
  'MGA': [0, 'Ar', 'MGA'],
435
  'MKD': [2, 'din', 'MKD'],
436
  'MMK': [0, 'K', 'MMK'],
437
  'MOP': [2, 'MOP', 'MOP$'],
438
  'MRO': [0, 'MRO', 'MRO'],
439
  'MUR': [0, 'MURs', 'MURs'],
440
  'MWK': [2, 'MWK', 'MWK'],
441
  'MZN': [2, 'MTn', 'MTn'],
442
  'NAD': [2, '$', 'N$'],
443
  'NGN': [2, '\u20A6', 'NG\u20A6'],
444
  'NIO': [2, 'C$', 'C$'],
445
  'NPR': [2, 'Rs', 'NPRs'],
446
  'NZD': [2, '$', 'NZ$'],
447
  'OMR': [3, 'Rial', 'OMR'],
448
  'PGK': [2, 'PGK', 'PGK'],
449
  'PYG': [16, 'Gs.', 'PYG'],
450
  'QAR': [2, 'Rial', 'QR'],
451
  'RWF': [0, 'RF', 'RF'],
452
  'SBD': [2, '$', 'SI$'],
453
  'SCR': [2, 'SCR', 'SCR'],
454
  'SDG': [2, 'SDG', 'SDG'],
455
  'SHP': [2, '£', 'SH£'],
456
  'SLL': [0, 'SLL', 'SLL'],
457
  'SOS': [0, 'SOS', 'SOS'],
458
  'SRD': [2, '$', 'SR$'],
459
  'SSP': [2, '£', 'SSP'],
460
  'STD': [0, 'Db', 'Db'],
461
  'SYP': [0, '£', 'SY£'],
462
  'SZL': [2, 'SZL', 'SZL'],
463
  'TJS': [2, 'Som', 'TJS'],
464
  'TND': [3, 'din', 'DT'],
465
  'TOP': [2, 'T$', 'T$'],
466
  'TTD': [2, '$', 'TT$'],
467
  'UGX': [0, 'UGX', 'UGX'],
468
  'UZS': [0, 'so\u02bcm', 'UZS'],
469
  'VEF': [2, 'Bs', 'Bs'],
470
  'VUV': [0, 'VUV', 'VUV'],
471
  'WST': [2, 'WST', 'WST'],
472
  'XAF': [0, 'FCFA', 'FCFA'],
473
  'XCD': [2, '$', 'EC$'],
474
  'XOF': [0, 'CFA', 'CFA'],
475
  'XPF': [48, 'FCFP', 'FCFP'],
476
  'ZMW': [0, 'ZMW', 'ZMW'],
477
  'ZWD': [0, '$', 'Z$']
478
};
479

480