sprintf in TypeScript

sprintf.ts

// Based on https://github.com/alexei/sprintf.js
//
// Copyright (c) 2007-present, Alexandru Mărășteanu <[email protected]>
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
//   notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
//   notice, this list of conditions and the following disclaimer in the
//   documentation and/or other materials provided with the distribution.
// * Neither the name of this software nor the names of its contributors may be
//   used to endorse or promote products derived from this software without
//   specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

const re = {
  not_string: /[^s]/,
  not_bool: /[^t]/,
  not_type: /[^T]/,
  not_primitive: /[^v]/,
  number: /[diefg]/,
  numeric_arg: /[bcdiefguxX]/,
  json: /[j]/,
  not_json: /[^j]/,
  text: /^[^\x25]+/,
  modulo: /^\x25{2}/,
  placeholder: /^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,
  key: /^([a-z_][a-z_\d]*)/i,
  key_access: /^\.([a-z_][a-z_\d]*)/i,
  index_access: /^\[(\d+)\]/,
  sign: /^[+-]/
}

export function sprintf(fmt: string, ...argv: any[]): string {
  return sprintf_format(sprintf_parse(fmt), argv)
}

var sprintf_cache = Object.create(null)

function sprintf_parse(fmt: string): any[] {
  if (sprintf_cache[fmt]) {
    return sprintf_cache[fmt]
  }

  var _fmt = fmt, match: null | any[], parse_tree = [], arg_names = 0
  while (_fmt) {
    if ((match = re.text.exec(_fmt)) !== null) {
      parse_tree.push(match[0])
    }
    else if ((match = re.modulo.exec(_fmt)) !== null) {
      parse_tree.push('%')
    }
    else if ((match = re.placeholder.exec(_fmt)) !== null) {
      if (match[2]) {
        arg_names |= 1
        var field_list = [], replacement_field = match[2], field_match: null | any[] = []
        if ((field_match = re.key.exec(replacement_field)) !== null) {
          field_list.push(field_match[1])
          while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
            if ((field_match = re.key_access.exec(replacement_field)) !== null) {
              field_list.push(field_match[1])
            }
            else if ((field_match = re.index_access.exec(replacement_field)) !== null) {
              field_list.push(field_match[1])
            }
            else {
              throw new SyntaxError('[sprintf] failed to parse named argument key')
            }
          }
        }
        else {
          throw new SyntaxError('[sprintf] failed to parse named argument key')
        }
        match[2] = field_list
      }
      else {
        arg_names |= 2
      }
      if (arg_names === 3) {
        throw new Error('[sprintf] mixing positional and named placeholders is not (yet) supported')
      }

      parse_tree.push(
        {
          placeholder: match[0],
          param_no: match[1],
          keys: match[2],
          sign: match[3],
          pad_char: match[4],
          align: match[5],
          width: match[6],
          precision: match[7],
          type: match[8]
        }
      )
    }
    else {
      throw new SyntaxError('[sprintf] unexpected placeholder')
    }
    _fmt = _fmt.substring(match[0].length)
  }
  return sprintf_cache[fmt] = parse_tree
}

function sprintf_format(parse_tree: any[], argv: any[]) {
  var cursor = 0, tree_length = parse_tree.length, arg, output = '', i, k, ph, pad, pad_character, pad_length, is_positive, sign
  for (i = 0; i < tree_length; i++) {
    if (typeof parse_tree[i] === 'string') {
      output += parse_tree[i]
    }
    else if (typeof parse_tree[i] === 'object') {
      ph = parse_tree[i] // convenience purposes only
      if (ph.keys) { // keyword argument
        arg = argv[cursor]
        for (k = 0; k < ph.keys.length; k++) {
          if (arg == undefined) {
            throw new Error(sprintf('[sprintf] Cannot access property "%s" of undefined value "%s"', ph.keys[k], ph.keys[k - 1]))
          }
          arg = arg[ph.keys[k]]
        }
      }
      else if (ph.param_no) { // positional argument (explicit)
        arg = argv[ph.param_no]
      }
      else { // positional argument (implicit)
        arg = argv[cursor++]
      }

      if (re.not_type.test(ph.type) && re.not_primitive.test(ph.type) && arg instanceof Function) {
        arg = arg()
      }

      if (re.numeric_arg.test(ph.type) && (typeof arg !== 'number' && isNaN(arg))) {
        throw new TypeError(sprintf('[sprintf] expecting number but found %T', arg))
      }

      if (re.number.test(ph.type)) {
        is_positive = arg >= 0
      }

      switch (ph.type) {
        case 'b':
          arg = parseInt(arg, 10).toString(2)
          break
        case 'c':
          arg = String.fromCharCode(parseInt(arg, 10))
          break
        case 'd':
        case 'i':
          arg = parseInt(arg, 10)
          break
        case 'j':
          arg = JSON.stringify(arg, null, ph.width ? parseInt(ph.width) : 0)
          break
        case 'e':
          arg = ph.precision ? parseFloat(arg).toExponential(ph.precision) : parseFloat(arg).toExponential()
          break
        case 'f':
          arg = ph.precision ? parseFloat(arg).toFixed(ph.precision) : parseFloat(arg)
          break
        case 'g':
          arg = ph.precision ? String(Number(arg.toPrecision(ph.precision))) : parseFloat(arg)
          break
        case 'o':
          arg = (parseInt(arg, 10) >>> 0).toString(8)
          break
        case 's':
          arg = String(arg)
          arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
          break
        case 't':
          arg = String(!!arg)
          arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
          break
        case 'T':
          arg = Object.prototype.toString.call(arg).slice(8, -1).toLowerCase()
          arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
          break
        case 'u':
          arg = parseInt(arg, 10) >>> 0
          break
        case 'v':
          arg = arg.valueOf()
          arg = (ph.precision ? arg.substring(0, ph.precision) : arg)
          break
        case 'x':
          arg = (parseInt(arg, 10) >>> 0).toString(16)
          break
        case 'X':
          arg = (parseInt(arg, 10) >>> 0).toString(16).toUpperCase()
          break
      }
      if (re.json.test(ph.type)) {
        output += arg
      }
      else {
        if (re.number.test(ph.type) && (!is_positive || ph.sign)) {
          sign = is_positive ? '+' : '-'
          arg = arg.toString().replace(re.sign, '')
        }
        else {
          sign = ''
        }
        pad_character = ph.pad_char ? ph.pad_char === '0' ? '0' : ph.pad_char.charAt(1) : ' '
        pad_length = ph.width - (sign + arg).length
        pad = ph.width ? (pad_length > 0 ? pad_character.repeat(pad_length) : '') : ''
        output += ph.align ? sign + arg + pad : (pad_character === '0' ? sign + pad + arg : pad + sign + arg)
      }
    }
  }
  return output
}