i18next-fs-backend/cjs/utils.js

i18next-fs-backend is a backend layer for i18next using in Node.js and for Deno to load translations from the filesystem.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.debounce = debounce;
exports.defaults = defaults;
exports.getPath = getPath;
exports.interpolate = interpolate;
exports.interpolatePath = interpolatePath;
exports.isSafeLangSegment = isSafeLangSegment;
exports.isSafeNsSegment = isSafeNsSegment;
exports.isSafePathSegment = void 0;
exports.pushPath = pushPath;
exports.setPath = setPath;
function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
var arr = [];
var each = arr.forEach;
var slice = arr.slice;
var UNSAFE_KEYS = ['__proto__', 'constructor', 'prototype'];
function defaults(obj) {
  each.call(slice.call(arguments, 1), function (source) {
    if (source) {
      for (var _i = 0, _Object$keys = Object.keys(source); _i < _Object$keys.length; _i++) {
        var prop = _Object$keys[_i];
        if (UNSAFE_KEYS.indexOf(prop) > -1) continue;
        if (obj[prop] === undefined) obj[prop] = source[prop];
      }
    }
  });
  return obj;
}
function isSafeSegmentBase(v) {
  if (typeof v !== 'string') return false;
  if (v.length === 0 || v.length > 128) return false;
  if (UNSAFE_KEYS.indexOf(v) > -1) return false;
  if (v.indexOf('..') > -1) return false;
  if (v.indexOf('\\') > -1) return false;
  if (/[\x00-\x1F\x7F]/.test(v)) return false;
  return true;
}
function isSafeLangSegment(v) {
  if (!isSafeSegmentBase(v)) return false;
  if (v.indexOf('/') > -1) return false;
  return true;
}
function isSafeNsSegment(v) {
  return isSafeSegmentBase(v);
}
var isSafePathSegment = exports.isSafePathSegment = isSafeLangSegment;
var SAFETY_CHECK_BY_KEY = {
  lng: isSafeLangSegment,
  ns: isSafeNsSegment
};
function debounce(func, wait, immediate) {
  var timeout;
  return function () {
    var context = this;
    var args = arguments;
    var later = function later() {
      timeout = null;
      if (!immediate) func.apply(context, args);
    };
    var callNow = immediate && !timeout;
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
    if (callNow) func.apply(context, args);
  };
}
function getLastOfPath(object, path, Empty) {
  function cleanKey(key) {
    return key && key.indexOf('###') > -1 ? key.replace(/###/g, '.') : key;
  }
  var stack = typeof path !== 'string' ? [].concat(path) : path.split('.');
  while (stack.length > 1) {
    if (!object) return {};
    var key = cleanKey(stack.shift());
    if (!object[key] && Empty) object[key] = new Empty();
    object = object[key];
  }
  if (!object) return {};
  return {
    obj: object,
    k: cleanKey(stack.shift())
  };
}
function setPath(object, path, newValue) {
  var _getLastOfPath = getLastOfPath(object, path, Object),
    obj = _getLastOfPath.obj,
    k = _getLastOfPath.k;
  if (Array.isArray(obj) && isNaN(k)) throw new Error("Cannot create property \"".concat(k, "\" here since object is an array"));
  obj[k] = newValue;
}
function pushPath(object, path, newValue, concat) {
  var _getLastOfPath2 = getLastOfPath(object, path, Object),
    obj = _getLastOfPath2.obj,
    k = _getLastOfPath2.k;
  obj[k] = obj[k] || [];
  if (concat) obj[k] = obj[k].concat(newValue);
  if (!concat) obj[k].push(newValue);
}
function getPath(object, path) {
  var _getLastOfPath3 = getLastOfPath(object, path),
    obj = _getLastOfPath3.obj,
    k = _getLastOfPath3.k;
  if (!obj) return undefined;
  return obj[k];
}
var interpolationRegexp = /\{\{(.+?)\}\}/g;
function interpolate(str, data) {
  return str.replace(interpolationRegexp, function (match, key) {
    var k = key.trim();
    if (UNSAFE_KEYS.indexOf(k) > -1) return match;
    var value = data[k];
    return value != null ? value : match;
  });
}
function interpolatePath(str, data) {
  var unsafe = false;
  var result = str.replace(interpolationRegexp, function (match, key) {
    var k = key.trim();
    if (UNSAFE_KEYS.indexOf(k) > -1) return match;
    var value = data[k];
    if (value == null) return match;
    var check = SAFETY_CHECK_BY_KEY[k] || isSafeLangSegment;
    var segments = String(value).split('+');
    var _iterator = _createForOfIteratorHelper(segments),
      _step;
    try {
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
        var seg = _step.value;
        if (!check(seg)) {
          unsafe = true;
          return match;
        }
      }
    } catch (err) {
      _iterator.e(err);
    } finally {
      _iterator.f();
    }
    return segments.join('+');
  });
  return unsafe ? null : result;
}