123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199
import * as utils from './utils.js';import baseLogger from './logger.js';
class Interpolator {  constructor(options = {}) {    this.logger = baseLogger.create('interpolator');
    this.options = options;    this.format = (options.interpolation && options.interpolation.format) || (value => value);    this.init(options);  }
  /* eslint no-param-reassign: 0 */  init(options = {}) {    if (!options.interpolation) options.interpolation = { escapeValue: true };
    const iOpts = options.interpolation;
    this.escape = iOpts.escape !== undefined ? iOpts.escape : utils.escape;    this.escapeValue = iOpts.escapeValue !== undefined ? iOpts.escapeValue : true;    this.useRawValueToEscape =      iOpts.useRawValueToEscape !== undefined ? iOpts.useRawValueToEscape : false;
    this.prefix = iOpts.prefix ? utils.regexEscape(iOpts.prefix) : iOpts.prefixEscaped || '{{';    this.suffix = iOpts.suffix ? utils.regexEscape(iOpts.suffix) : iOpts.suffixEscaped || '}}';
    this.formatSeparator = iOpts.formatSeparator      ? iOpts.formatSeparator      : iOpts.formatSeparator || ',';
    this.unescapePrefix = iOpts.unescapeSuffix ? '' : iOpts.unescapePrefix || '-';    this.unescapeSuffix = this.unescapePrefix ? '' : iOpts.unescapeSuffix || '';
    this.nestingPrefix = iOpts.nestingPrefix      ? utils.regexEscape(iOpts.nestingPrefix)      : iOpts.nestingPrefixEscaped || utils.regexEscape('$t(');    this.nestingSuffix = iOpts.nestingSuffix      ? utils.regexEscape(iOpts.nestingSuffix)      : iOpts.nestingSuffixEscaped || utils.regexEscape(')');
    this.maxReplaces = iOpts.maxReplaces ? iOpts.maxReplaces : 1000;
    // the regexp    this.resetRegExp();  }
  reset() {    if (this.options) this.init(this.options);  }
  resetRegExp() {    // the regexp    const regexpStr = `${this.prefix}(.+?)${this.suffix}`;    this.regexp = new RegExp(regexpStr, 'g');
    const regexpUnescapeStr = `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${      this.suffix    }`;    this.regexpUnescape = new RegExp(regexpUnescapeStr, 'g');
    const nestingRegexpStr = `${this.nestingPrefix}(.+?)${this.nestingSuffix}`;    this.nestingRegexp = new RegExp(nestingRegexpStr, 'g');  }
  interpolate(str, data, lng, options) {    let match;    let value;    let replaces;
    const defaultData =      (this.options && this.options.interpolation && this.options.interpolation.defaultVariables) ||      {};
    function regexSafe(val) {      return val.replace(/\$/g, '$$$$');    }
    const handleFormat = key => {      if (key.indexOf(this.formatSeparator) < 0) {        return utils.getPathWithDefaults(data, defaultData, key);      }
      const p = key.split(this.formatSeparator);      const k = p.shift().trim();      const f = p.join(this.formatSeparator).trim();
      return this.format(utils.getPathWithDefaults(data, defaultData, k), f, lng);    };
    this.resetRegExp();
    const missingInterpolationHandler =      (options && options.missingInterpolationHandler) || this.options.missingInterpolationHandler;
    replaces = 0;    // unescape if has unescapePrefix/Suffix    /* eslint no-cond-assign: 0 */    while ((match = this.regexpUnescape.exec(str))) {      value = handleFormat(match[1].trim());      if (value === undefined) {        if (typeof missingInterpolationHandler === 'function') {          const temp = missingInterpolationHandler(str, match, options);          value = typeof temp === 'string' ? temp : '';        } else {          this.logger.warn(`missed to pass in variable ${match[1]} for interpolating ${str}`);          value = '';        }      } else if (typeof value !== 'string' && !this.useRawValueToEscape) {        value = utils.makeString(value);      }      str = str.replace(match[0], regexSafe(value));      this.regexpUnescape.lastIndex = 0;      replaces++;      if (replaces >= this.maxReplaces) {        break;      }    }
    replaces = 0;    // regular escape on demand    while ((match = this.regexp.exec(str))) {      value = handleFormat(match[1].trim());      if (value === undefined) {        if (typeof missingInterpolationHandler === 'function') {          const temp = missingInterpolationHandler(str, match, options);          value = typeof temp === 'string' ? temp : '';        } else {          this.logger.warn(`missed to pass in variable ${match[1]} for interpolating ${str}`);          value = '';        }      } else if (typeof value !== 'string' && !this.useRawValueToEscape) {        value = utils.makeString(value);      }      value = this.escapeValue ? regexSafe(this.escape(value)) : regexSafe(value);      str = str.replace(match[0], value);      this.regexp.lastIndex = 0;      replaces++;      if (replaces >= this.maxReplaces) {        break;      }    }    return str;  }
  nest(str, fc, options = {}) {    let match;    let value;
    let clonedOptions = { ...options };    clonedOptions.applyPostProcessor = false; // avoid post processing on nested lookup    delete clonedOptions.defaultValue; // assert we do not get a endless loop on interpolating defaultValue again and again
    // if value is something like "myKey": "lorem $(anotherKey, { "count": {{aValueInOptions}} })"    function handleHasOptions(key, inheritedOptions) {      if (key.indexOf(',') < 0) return key;
      const p = key.split(',');      key = p.shift();      let optionsString = p.join(',');      optionsString = this.interpolate(optionsString, clonedOptions);      optionsString = optionsString.replace(/'/g, '"');
      try {        clonedOptions = JSON.parse(optionsString);
        if (inheritedOptions) clonedOptions = { ...inheritedOptions, ...clonedOptions };      } catch (e) {        this.logger.error(`failed parsing options string in nesting for key ${key}`, e);      }
      // assert we do not get a endless loop on interpolating defaultValue again and again      delete clonedOptions.defaultValue;      return key;    }
    // regular escape on demand    while ((match = this.nestingRegexp.exec(str))) {      value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
      // is only the nesting key (key1 = '$(key2)') return the value without stringify      if (value && match[0] === str && typeof value !== 'string') return value;
      // no string to include or empty      if (typeof value !== 'string') value = utils.makeString(value);      if (!value) {        this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);        value = '';      }      // Nested keys should not be escaped by default #854      // value = this.escapeValue ? regexSafe(utils.escape(value)) : regexSafe(value);      str = str.replace(match[0], value);      this.regexp.lastIndex = 0;    }    return str;  }}
export default Interpolator;