resources/src/mediawiki.language/mediawiki.language.numbers.js

   1 /*
   2  * Number-related utilities for mediawiki.language.
   3  */
   4 ( function ( mw, $ ) {
   5         /**
   6          * @class mw.language
   7          */
   8
   9         /**
  10          * Replicate a string 'n' times.
  11          *
  12          * @private
  13          * @param {string} str The string to replicate
  14          * @param {number} num Number of times to replicate the string
  15          * @return {string}
  16          */
  17         function replicate( str, num ) {
  18                 var buf = [];
  19
  20                 if ( num <= 0 || !str ) {
  21                         return '';
  22                 }
  23
  24                 while ( num-- ) {
  25                         buf.push( str );
  26                 }
  27                 return buf.join( '' );
  28         }
  29
  30         /**
  31          * Pad a string to guarantee that it is at least `size` length by
  32          * filling with the character `ch` at either the start or end of the
  33          * string. Pads at the start, by default.
  34          *
  35          * Example: Fill the string to length 10 with '+' characters on the right.
  36          *
  37          *     pad( 'blah', 10, '+', true ); // => 'blah++++++'
  38          *
  39          * @private
  40          * @param {string} text The string to pad
  41          * @param {number} size The length to pad to
  42          * @param {string} [ch='0'] Character to pad with
  43          * @param {boolean} [end=false] Adds padding at the end if true, otherwise pads at start
  44          * @return {string}
  45          */
  46         function pad( text, size, ch, end ) {
  47                 var out, padStr;
  48
  49                 if ( !ch ) {
  50                         ch = '0';
  51                 }
  52
  53                 out = String( text );
  54                 padStr = replicate( ch, Math.ceil( ( size - out.length ) / ch.length ) );
  55
  56                 return end ? out + padStr : padStr + out;
  57         }
  58
  59         /**
  60          * Apply numeric pattern to absolute value using options. Gives no
  61          * consideration to local customs.
  62          *
  63          * Adapted from dojo/number library with thanks
  64          * <http://dojotoolkit.org/reference-guide/1.8/dojo/number.html>
  65          *
  66          * @private
  67          * @param {number} value the number to be formatted, ignores sign
  68          * @param {string} pattern the number portion of a pattern (e.g. `#,##0.00`)
  69          * @param {Object} [options] If provided, all option keys must be present:
  70          * @param {string} options.decimal The decimal separator. Defaults to: `'.'`.
  71          * @param {string} options.group The group separator. Defaults to: `','`.
  72          * @param {number|null} options.minimumGroupingDigits
  73          * @return {string}
  74          */
  75         function commafyNumber( value, pattern, options ) {
  76                 var padLength,
  77                         patternDigits,
  78                         index,
  79                         whole,
  80                         off,
  81                         remainder,
  82                         patternParts = pattern.split( '.' ),
  83                         maxPlaces = ( patternParts[ 1 ] || [] ).length,
  84                         valueParts = String( Math.abs( value ) ).split( '.' ),
  85                         fractional = valueParts[ 1 ] || '',
  86                         groupSize = 0,
  87                         groupSize2 = 0,
  88                         pieces = [];
  89
  90                 options = options || {
  91                         group: ',',
  92                         decimal: '.'
  93                 };
  94
  95                 if ( isNaN( value ) ) {
  96                         return value;
  97                 }
  98
  99                 if ( patternParts[ 1 ] ) {
 100                         // Pad fractional with trailing zeros
 101                         padLength = ( patternParts[ 1 ] && patternParts[ 1 ].lastIndexOf( '0' ) + 1 );
 102
 103                         if ( padLength > fractional.length ) {
 104                                 valueParts[ 1 ] = pad( fractional, padLength, '0', true );
 105                         }
 106
 107                         // Truncate fractional
 108                         if ( maxPlaces < fractional.length ) {
 109                                 valueParts[ 1 ] = fractional.slice( 0, maxPlaces );
 110                         }
 111                 } else {
 112                         if ( valueParts[ 1 ] ) {
 113                                 valueParts.pop();
 114                         }
 115                 }
 116
 117                 // Pad whole with leading zeros
 118                 patternDigits = patternParts[ 0 ].replace( ',', '' );
 119
 120                 padLength = patternDigits.indexOf( '0' );
 121
 122                 if ( padLength !== -1 ) {
 123                         padLength = patternDigits.length - padLength;
 124
 125                         if ( padLength > valueParts[ 0 ].length ) {
 126                                 valueParts[ 0 ] = pad( valueParts[ 0 ], padLength );
 127                         }
 128
 129                         // Truncate whole
 130                         if ( patternDigits.indexOf( '#' ) === -1 ) {
 131                                 valueParts[ 0 ] = valueParts[ 0 ].slice( valueParts[ 0 ].length - padLength );
 132                         }
 133                 }
 134
 135                 // Add group separators
 136                 index = patternParts[ 0 ].lastIndexOf( ',' );
 137
 138                 if ( index !== -1 ) {
 139                         groupSize = patternParts[ 0 ].length - index - 1;
 140                         remainder = patternParts[ 0 ].slice( 0, index );
 141                         index = remainder.lastIndexOf( ',' );
 142                         if ( index !== -1 ) {
 143                                 groupSize2 = remainder.length - index - 1;
 144                         }
 145                 }
 146
 147                 if (
 148                         options.minimumGroupingDigits === null ||
 149                         valueParts[ 0 ].length >= groupSize + options.minimumGroupingDigits
 150                 ) {
 151                         for ( whole = valueParts[ 0 ]; whole; ) {
 152                                 off = groupSize ? whole.length - groupSize : 0;
 153                                 pieces.push( ( off > 0 ) ? whole.slice( off ) : whole );
 154                                 whole = ( off > 0 ) ? whole.slice( 0, off ) : '';
 155
 156                                 if ( groupSize2 ) {
 157                                         groupSize = groupSize2;
 158                                         groupSize2 = null;
 159                                 }
 160                         }
 161                         valueParts[ 0 ] = pieces.reverse().join( options.group );
 162                 }
 163
 164                 return valueParts.join( options.decimal );
 165         }
 166
 167         /**
 168          * Helper function to flip transformation tables.
 169          *
 170          * @param {...Object} Transformation tables
 171          * @return {Object}
 172          */
 173         function flipTransform() {
 174                 var i, key, table, flipped = {};
 175
 176                 // Ensure we strip thousand separators. This might be overwritten.
 177                 flipped[ ',' ] = '';
 178
 179                 for ( i = 0; i < arguments.length; i++ ) {
 180                         table = arguments[ i ];
 181                         for ( key in table ) {
 182                                 // The thousand separator should be deleted
 183                                 flipped[ table[ key ] ] = key === ',' ? '' : key;
 184                         }
 185                 }
 186
 187                 return flipped;
 188         }
 189
 190         $.extend( mw.language, {
 191
 192                 /**
 193                  * Converts a number using #getDigitTransformTable.
 194                  *
 195                  * @param {number} num Value to be converted
 196                  * @param {boolean} [integer=false] Whether to convert the return value to an integer
 197                  * @return {number|string} Formatted number
 198                  */
 199                 convertNumber: function ( num, integer ) {
 200                         var transformTable, digitTransformTable, separatorTransformTable,
 201                                 i, numberString, convertedNumber, pattern, minimumGroupingDigits;
 202
 203                         // Quick shortcut for plain numbers
 204                         if ( integer && parseInt( num, 10 ) === num ) {
 205                                 return num;
 206                         }
 207
 208                         // Load the transformation tables (can be empty)
 209                         digitTransformTable = mw.language.getDigitTransformTable();
 210                         separatorTransformTable = mw.language.getSeparatorTransformTable();
 211
 212                         if ( integer ) {
 213                                 // Reverse the digit transformation tables if we are doing unformatting
 214                                 transformTable = flipTransform( separatorTransformTable, digitTransformTable );
 215                                 numberString = String( num );
 216                         } else {
 217                                 // This check being here means that digits can still be unformatted
 218                                 // even if we do not produce them. This seems sane behavior.
 219                                 if ( mw.config.get( 'wgTranslateNumerals' ) ) {
 220                                         transformTable = digitTransformTable;
 221                                 }
 222
 223                                 // Commaying is more complex, so we handle it here separately.
 224                                 // When unformatting, we just use separatorTransformTable.
 225                                 pattern = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 226                                         'digitGroupingPattern' ) || '#,##0.###';
 227                                 minimumGroupingDigits = mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 228                                         'minimumGroupingDigits' ) || null;
 229                                 numberString = mw.language.commafy( num, pattern, minimumGroupingDigits );
 230                         }
 231
 232                         if ( transformTable ) {
 233                                 convertedNumber = '';
 234                                 for ( i = 0; i < numberString.length; i++ ) {
 235                                         if ( Object.prototype.hasOwnProperty.call( transformTable, numberString[ i ] ) ) {
 236                                                 convertedNumber += transformTable[ numberString[ i ] ];
 237                                         } else {
 238                                                 convertedNumber += numberString[ i ];
 239                                         }
 240                                 }
 241                         } else {
 242                                 convertedNumber = numberString;
 243                         }
 244
 245                         if ( integer ) {
 246                                 // Parse string to integer. This loses decimals!
 247                                 convertedNumber = parseInt( convertedNumber, 10 );
 248                         }
 249
 250                         return convertedNumber;
 251                 },
 252
 253                 /**
 254                  * Get the digit transform table for current UI language.
 255                  *
 256                  * @return {Object|Array}
 257                  */
 258                 getDigitTransformTable: function () {
 259                         return mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 260                                 'digitTransformTable' ) || [];
 261                 },
 262
 263                 /**
 264                  * Get the separator transform table for current UI language.
 265                  *
 266                  * @return {Object|Array}
 267                  */
 268                 getSeparatorTransformTable: function () {
 269                         return mw.language.getData( mw.config.get( 'wgUserLanguage' ),
 270                                 'separatorTransformTable' ) || [];
 271                 },
 272
 273                 /**
 274                  * Apply pattern to format value as a string.
 275                  *
 276                  * Using patterns from [Unicode TR35](https://www.unicode.org/reports/tr35/#Number_Format_Patterns).
 277                  *
 278                  * @param {number} value
 279                  * @param {string} pattern Pattern string as described by Unicode TR35
 280                  * @param {number|null} [minimumGroupingDigits=null]
 281                  * @throws {Error} If unable to find a number expression in `pattern`.
 282                  * @return {string}
 283                  */
 284                 commafy: function ( value, pattern, minimumGroupingDigits ) {
 285                         var numberPattern,
 286                                 transformTable = mw.language.getSeparatorTransformTable(),
 287                                 group = transformTable[ ',' ] || ',',
 288                                 numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/, // not precise, but good enough
 289                                 decimal = transformTable[ '.' ] || '.',
 290                                 patternList = pattern.split( ';' ),
 291                                 positivePattern = patternList[ 0 ];
 292
 293                         pattern = patternList[ ( value < 0 ) ? 1 : 0 ] || ( '-' + positivePattern );
 294                         numberPattern = positivePattern.match( numberPatternRE );
 295                         minimumGroupingDigits = minimumGroupingDigits !== undefined ? minimumGroupingDigits : null;
 296
 297                         if ( !numberPattern ) {
 298                                 throw new Error( 'unable to find a number expression in pattern: ' + pattern );
 299                         }
 300
 301                         return pattern.replace( numberPatternRE, commafyNumber( value, numberPattern[ 0 ], {
 302                                 minimumGroupingDigits: minimumGroupingDigits,
 303                                 decimal: decimal,
 304                                 group: group
 305                         } ) );
 306                 }
 307
 308         } );
 309
 310 }( mediaWiki, jQuery ) );