i18next-http-middleware 2.1.1 → 3.0.2

package/esm/httpFunctions.js

@@ -0,0 +1,120 @@
+export var getPath = function getPath(req) {
+  if (req.path) return req.path;
+  if (req.raw && req.raw.path) return req.raw.path;
+  if (req.url) return req.url;
+  console.log('no possibility found to get path');
+};
+export var getUrl = function getUrl(req) {
+  if (req.url) return req.url;
+  if (req.raw && req.raw.url) return req.raw.url;
+  console.log('no possibility found to get url');
+};
+export var setUrl = function setUrl(req, url) {
+  if (req.url) {
+    req.url = url;
+    return;
+  }
+
+  console.log('no possibility found to get url');
+};
+export var getOriginalUrl = function getOriginalUrl(req) {
+  if (req.originalUrl) return req.originalUrl;
+  if (req.raw && req.raw.originalUrl) return req.raw.originalUrl;
+  return getUrl(req);
+};
+export var getQuery = function getQuery(req) {
+  if (req.query && typeof req.query.entries === 'function' && typeof Object.fromEntries === 'function') return Object.fromEntries(req.query);
+  if (req.query) return req.query;
+  if (req.raw && req.raw.query) return req.raw.query;
+  if (req.ctx && req.ctx.queryParams) return req.ctx.queryParams;
+  var url = req.url || req.raw && req.raw.url;
+  if (url && url.indexOf('?') < 0) return {};
+  console.log('no possibility found to get query');
+  return {};
+};
+export var getParams = function getParams(req) {
+  if (req.params) return req.params;
+  if (req.raw && req.raw.params) return req.raw.params;
+  if (req.ctx && req.ctx.params) return req.ctx.params;
+  console.log('no possibility found to get params');
+  return {};
+};
+export var getHeaders = function getHeaders(req) {
+  if (req.headers) return req.headers;
+  console.log('no possibility found to get headers');
+};
+export var getCookies = function getCookies(req) {
+  if (req.cookies) return req.cookies;
+
+  if (getHeaders(req)) {
+    var list = {};
+    var rc = getHeaders(req).cookie;
+    rc && rc.split(';').forEach(function (cookie) {
+      var parts = cookie.split('=');
+      list[parts.shift().trim()] = decodeURI(parts.join('='));
+    });
+    return list;
+  }
+
+  console.log('no possibility found to get cookies');
+};
+export var getBody = function getBody(req) {
+  if (req.ctx && req.ctx.body) return req.ctx.body.bind(req.ctx);
+  if (req.json) return req.json;
+  if (req.body) return req.body;
+  console.log('no possibility found to get body');
+  return {};
+};
+export var getHeader = function getHeader(res, name) {
+  if (res.getHeader) return res.getHeader(name);
+  if (res.headers) return res.headers[name];
+  if (getHeaders(res) && getHeaders(res)[name]) return getHeaders(res)[name];
+  console.log('no possibility found to get header');
+  return undefined;
+};
+export var setHeader = function setHeader(res, name, value) {
+  if (res._headerSent || res.headersSent) return;
+  if (typeof res.setHeader === 'function') return res.setHeader(name, value);
+  if (typeof res.header === 'function') return res.header(name, value);
+  if (res.responseHeaders && typeof res.responseHeaders.set === 'function') return res.responseHeaders.set(name, value);
+  if (res.headers && typeof res.headers.set === 'function') return res.headers.set(name, value);
+  console.log('no possibility found to set header');
+};
+export var setContentType = function setContentType(res, type) {
+  if (typeof res.contentType === 'function') return res.contentType(type);
+  if (typeof res.type === 'function') return res.type(type);
+  setHeader(res, 'Content-Type', type);
+};
+export var setStatus = function setStatus(res, code) {
+  if (typeof res.status === 'function') return res.status(code);
+  if (res.status) return res.status = code;
+  console.log('no possibility found to set status');
+};
+export var send = function send(res, body) {
+  if (typeof res.send === 'function') return res.send(body);
+  return body;
+};
+export var getSession = function getSession(req) {
+  if (req.session) return req.session;
+  if (req.raw && req.raw.session) return req.raw.session;
+  console.log('no possibility found to get session');
+};
+export var extendOptionsWithDefaults = function extendOptionsWithDefaults() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  options.getPath = options.getPath || getPath;
+  options.getOriginalUrl = options.getOriginalUrl || getOriginalUrl;
+  options.getUrl = options.getUrl || getUrl;
+  options.setUrl = options.setUrl || setUrl;
+  options.getParams = options.getParams || getParams;
+  options.getSession = options.getSession || getSession;
+  options.getQuery = options.getQuery || getQuery;
+  options.getCookies = options.getCookies || getCookies;
+  options.getBody = options.getBody || getBody;
+  options.getHeaders = options.getHeaders || getHeaders;
+  options.getHeader = options.getHeader || getHeader;
+  options.setHeader = options.setHeader || setHeader;
+  options.setContentType = options.setContentType || setContentType;
+  options.setStatus = options.setStatus || setStatus;
+  options.send = options.send || send;
+  return options;
+};

package/esm/index.js

@@ -0,0 +1,229 @@
+import * as utils from './utils.js';
+import LD from './LanguageDetector.js';
+import { extendOptionsWithDefaults } from './httpFunctions.js';
+export var LanguageDetector = LD;
+
+var checkForCombinedReqRes = function checkForCombinedReqRes(req, res, next) {
+  if (!res) {
+    if (req.request && req.response) {
+      res = req.response;
+      if (!req.request.ctx) req.request.ctx = req;
+      req = req.request;
+      if (!next) next = function next() {};
+    } else if (req.respond) {
+      res = req;
+      if (!next) next = function next() {};
+    }
+  }
+
+  return {
+    req: req,
+    res: res,
+    next: next
+  };
+};
+
+export function handle(i18next) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  extendOptionsWithDefaults(options);
+  return function i18nextMiddleware(rq, rs, n) {
+    var _checkForCombinedReqR = checkForCombinedReqRes(rq, rs, n),
+        req = _checkForCombinedReqR.req,
+        res = _checkForCombinedReqR.res,
+        next = _checkForCombinedReqR.next;
+
+    if (typeof options.ignoreRoutes === 'function') {
+      if (options.ignoreRoutes(req, res, options, i18next)) {
+        return next();
+      }
+    } else {
+      var ignores = options.ignoreRoutes instanceof Array && options.ignoreRoutes || [];
+
+      for (var i = 0; i < ignores.length; i++) {
+        if (options.getPath(req).indexOf(ignores[i]) > -1) return next();
+      }
+    }
+
+    var i18n = i18next.cloneInstance({
+      initImmediate: false
+    });
+    i18n.on('languageChanged', function (lng) {
+      req.language = req.locale = req.lng = lng;
+
+      if (res.locals) {
+        res.locals.language = lng;
+        res.locals.languageDir = i18next.dir(lng);
+      }
+
+      if (lng && options.getHeader(res, 'Content-Language') !== lng) {
+        options.setHeader(res, 'Content-Language', lng);
+      }
+
+      req.languages = i18next.services.languageUtils.toResolveHierarchy(lng);
+
+      if (i18next.services.languageDetector) {
+        i18next.services.languageDetector.cacheUserLanguage(req, res, lng);
+      }
+    });
+    var lng = req.lng;
+    if (!lng && i18next.services.languageDetector) lng = i18next.services.languageDetector.detect(req, res);
+    req.language = req.locale = req.lng = lng;
+
+    if (lng && options.getHeader(res, 'Content-Language') !== lng) {
+      options.setHeader(res, 'Content-Language', lng);
+    }
+
+    req.languages = i18next.services.languageUtils.toResolveHierarchy(lng);
+    i18n.changeLanguage(lng || i18next.options.fallbackLng[0]);
+
+    if (req.i18nextLookupName === 'path' && options.removeLngFromUrl) {
+      options.setUrl(req, utils.removeLngFromUrl(options.getUrl(req), i18next.services.languageDetector.options.lookupFromPathIndex));
+    }
+
+    var t = i18n.t.bind(i18n);
+    var exists = i18n.exists.bind(i18n);
+    req.i18n = i18n;
+    req.t = t;
+
+    if (res.locals) {
+      res.locals.t = t;
+      res.locals.exists = exists;
+      res.locals.i18n = i18n;
+      res.locals.language = lng;
+      res.locals.languageDir = i18next.dir(lng);
+    }
+
+    if (i18next.services.languageDetector) i18next.services.languageDetector.cacheUserLanguage(req, res, lng);
+    if (!req.lng) return next();
+    i18next.loadLanguages(req.lng, function () {
+      return next();
+    });
+  };
+}
+export function plugin(instance, options, next) {
+  var middleware = handle(options.i18next, options);
+  instance.addHook('preHandler', function (request, reply, next) {
+    return middleware(request, reply, next);
+  });
+  return next();
+}
+plugin[Symbol.for('skip-override')] = true;
+export function getResourcesHandler(i18next) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  extendOptionsWithDefaults(options);
+  var maxAge = options.maxAge || 60 * 60 * 24 * 30;
+  return function (rq, rs) {
+    var _checkForCombinedReqR2 = checkForCombinedReqRes(rq, rs),
+        req = _checkForCombinedReqR2.req,
+        res = _checkForCombinedReqR2.res;
+
+    if (!i18next.services.backendConnector) {
+      options.setStatus(res, 404);
+      return options.send(res, 'i18next-express-middleware:: no backend configured');
+    }
+
+    var resources = {};
+    options.setContentType(res, 'application/json');
+
+    if (options.cache !== undefined ? options.cache : typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'production') {
+      options.setHeader(res, 'Cache-Control', 'public, max-age=' + maxAge);
+      options.setHeader(res, 'Expires', new Date(new Date().getTime() + maxAge * 1000).toUTCString());
+    } else {
+      options.setHeader(res, 'Pragma', 'no-cache');
+      options.setHeader(res, 'Cache-Control', 'no-cache');
+    }
+
+    var languages = options.getQuery(req)[options.lngParam || 'lng'] ? options.getQuery(req)[options.lngParam || 'lng'].split(' ') : [];
+    var namespaces = options.getQuery(req)[options.nsParam || 'ns'] ? options.getQuery(req)[options.nsParam || 'ns'].split(' ') : [];
+    namespaces.forEach(function (ns) {
+      if (i18next.options.ns && i18next.options.ns.indexOf(ns) < 0) i18next.options.ns.push(ns);
+    });
+    i18next.services.backendConnector.load(languages, namespaces, function () {
+      languages.forEach(function (lng) {
+        namespaces.forEach(function (ns) {
+          utils.setPath(resources, [lng, ns], i18next.getResourceBundle(lng, ns));
+        });
+      });
+    });
+    return options.send(res, resources);
+  };
+}
+export function missingKeyHandler(i18next) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  extendOptionsWithDefaults(options);
+  return function (rq, rs) {
+    var _checkForCombinedReqR3 = checkForCombinedReqRes(rq, rs),
+        req = _checkForCombinedReqR3.req,
+        res = _checkForCombinedReqR3.res;
+
+    var lng = options.getParams(req)[options.lngParam || 'lng'];
+    var ns = options.getParams(req)[options.nsParam || 'ns'];
+
+    if (!i18next.services.backendConnector) {
+      options.setStatus(res, 404);
+      return options.send(res, 'i18next-express-middleware:: no backend configured');
+    }
+
+    var body = options.getBody(req);
+
+    if (typeof body === 'function') {
+      var promise = body();
+
+      if (promise && typeof promise.then === 'function') {
+        return new Promise(function (resolve) {
+          promise.then(function (b) {
+            for (var m in b) {
+              i18next.services.backendConnector.saveMissing([lng], ns, m, b[m]);
+            }
+
+            resolve(options.send(res, 'ok'));
+          });
+        });
+      }
+    }
+
+    for (var m in body) {
+      i18next.services.backendConnector.saveMissing([lng], ns, m, body[m]);
+    }
+
+    return options.send(res, 'ok');
+  };
+}
+export function addRoute(i18next, route, lngs, app, verb, fc) {
+  if (typeof verb === 'function') {
+    fc = verb;
+    verb = 'get';
+  }
+
+  var callbacks = [fc].concat(Array.prototype.slice.call(arguments, 6));
+
+  for (var i = 0, li = lngs.length; i < li; i++) {
+    var parts = String(route).split('/');
+    var locRoute = [];
+
+    for (var y = 0, ly = parts.length; y < ly; y++) {
+      var part = parts[y];
+
+      if (part === ':lng') {
+        locRoute.push(lngs[i]);
+      } else if (part.indexOf(':') === 0 || part === '') {
+        locRoute.push(part);
+      } else {
+        locRoute.push(i18next.t(part, {
+          lng: lngs[i]
+        }));
+      }
+    }
+
+    var routes = [locRoute.join('/')];
+    app[verb || 'get'].apply(app, routes.concat(callbacks));
+  }
+}
+export default {
+  plugin: plugin,
+  handle: handle,
+  getResourcesHandler: getResourcesHandler,
+  missingKeyHandler: missingKeyHandler,
+  addRoute: addRoute,
+  LanguageDetector: LanguageDetector
+};

package/esm/languageLookups/cookie.js

@@ -0,0 +1,112 @@
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+
+var serializeCookie = function serializeCookie(name, val, options) {
+  var opt = options || {};
+  opt.path = opt.path || '/';
+  var value = encodeURIComponent(val);
+  var str = name + '=' + value;
+
+  if (opt.maxAge > 0) {
+    var maxAge = opt.maxAge - 0;
+    if (isNaN(maxAge)) throw new Error('maxAge should be a Number');
+    str += '; Max-Age=' + Math.floor(maxAge);
+  }
+
+  if (opt.domain) {
+    if (!fieldContentRegExp.test(opt.domain)) {
+      throw new TypeError('option domain is invalid');
+    }
+
+    str += '; Domain=' + opt.domain;
+  }
+
+  if (opt.path) {
+    if (!fieldContentRegExp.test(opt.path)) {
+      throw new TypeError('option path is invalid');
+    }
+
+    str += '; Path=' + opt.path;
+  }
+
+  if (opt.expires) {
+    if (typeof opt.expires.toUTCString !== 'function') {
+      throw new TypeError('option expires is invalid');
+    }
+
+    str += '; Expires=' + opt.expires.toUTCString();
+  }
+
+  if (opt.httpOnly) str += '; HttpOnly';
+  if (opt.secure) str += '; Secure';
+
+  if (opt.sameSite) {
+    var sameSite = typeof opt.sameSite === 'string' ? opt.sameSite.toLowerCase() : opt.sameSite;
+
+    switch (sameSite) {
+      case true:
+        str += '; SameSite=Strict';
+        break;
+
+      case 'lax':
+        str += '; SameSite=Lax';
+        break;
+
+      case 'strict':
+        str += '; SameSite=Strict';
+        break;
+
+      case 'none':
+        str += '; SameSite=None';
+        break;
+
+      default:
+        throw new TypeError('option sameSite is invalid');
+    }
+  }
+
+  return str;
+};
+
+export default {
+  name: 'cookie',
+  lookup: function lookup(req, res, options) {
+    var found;
+
+    if (options.lookupCookie && typeof req !== 'undefined') {
+      var cookies = options.getCookies(req);
+      found = cookies[options.lookupCookie];
+    }
+
+    return found;
+  },
+  cacheUserLanguage: function cacheUserLanguage(req, res, lng) {
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+    if (options.lookupCookie && req !== 'undefined') {
+      var expirationDate = options.cookieExpirationDate;
+
+      if (!expirationDate) {
+        expirationDate = new Date();
+        expirationDate.setFullYear(expirationDate.getFullYear() + 1);
+      }
+
+      var cookieOptions = {
+        expires: expirationDate,
+        domain: options.cookieDomain,
+        path: options.cookiePath,
+        httpOnly: false,
+        overwrite: true,
+        sameSite: options.cookieSameSite
+      };
+      if (options.cookieSecure) cookieOptions.secure = options.cookieSecure;
+      var existingCookie = options.getHeader(res, 'set-cookie') || options.getHeader(res, 'Set-Cookie') || [];
+      if (typeof existingCookie === 'string') existingCookie = [existingCookie];
+      if (!Array.isArray(existingCookie)) existingCookie = [];
+      existingCookie = existingCookie.filter(function (c) {
+        return c.indexOf("".concat(options.lookupCookie, "=")) !== 0;
+      });
+      existingCookie.push(serializeCookie(options.lookupCookie, lng, cookieOptions));
+      options.setHeader(res, 'Set-Cookie', existingCookie.length === 1 ? existingCookie[0] : existingCookie);
+    }
+  }
+};

package/esm/languageLookups/header.js

@@ -0,0 +1,59 @@
+var specialCases = ['hans', 'hant', 'latn', 'cyrl', 'cans', 'mong', 'arab'];
+export default {
+  name: 'header',
+  lookup: function lookup(req, res, options) {
+    var found;
+
+    if (typeof req !== 'undefined') {
+      var headers = options.getHeaders(req);
+      if (!headers) return found;
+      var locales = [];
+      var acceptLanguage = options.lookupHeader ? headers[options.lookupHeader] : headers['accept-language'];
+
+      if (acceptLanguage) {
+        var lookupRegex = /(([a-z]{2})-?([A-Z]{2})?)\s*;?\s*(q=([0-9.]+))?/gi;
+
+        if (acceptLanguage.indexOf('-') > 0) {
+          var foundSpecialCase = specialCases.find(function (s) {
+            return acceptLanguage.toLowerCase().indexOf("-".concat(s)) > 0;
+          });
+          if (foundSpecialCase) lookupRegex = /(([a-z]{2})-?([A-Z]{4})?)\s*;?\s*(q=([0-9.]+))?/gi;
+        }
+
+        var lngs = [];
+        var i;
+        var m;
+        var rgx = options.lookupHeaderRegex || lookupRegex;
+
+        do {
+          m = rgx.exec(acceptLanguage);
+
+          if (m) {
+            var lng = m[1];
+            var weight = m[5] || '1';
+            var q = Number(weight);
+
+            if (lng && !isNaN(q)) {
+              lngs.push({
+                lng: lng,
+                q: q
+              });
+            }
+          }
+        } while (m);
+
+        lngs.sort(function (a, b) {
+          return b.q - a.q;
+        });
+
+        for (i = 0; i < lngs.length; i++) {
+          locales.push(lngs[i].lng);
+        }
+
+        if (locales.length) found = locales;
+      }
+    }
+
+    return found;
+  }
+};

package/esm/languageLookups/path.js

@@ -0,0 +1,29 @@
+export default {
+  name: 'path',
+  lookup: function lookup(req, res, options) {
+    var found;
+
+    if (req === undefined) {
+      return found;
+    }
+
+    if (options.lookupPath !== undefined && req.params) {
+      found = options.getParams(req)[options.lookupPath];
+    }
+
+    if (!found && typeof options.lookupFromPathIndex === 'number' && options.getOriginalUrl(req)) {
+      var path = options.getOriginalUrl(req).split('?')[0];
+      var parts = path.split('/');
+
+      if (parts[0] === '') {
+        parts.shift();
+      }
+
+      if (parts.length > options.lookupFromPathIndex) {
+        found = parts[options.lookupFromPathIndex];
+      }
+    }
+
+    return found;
+  }
+};

package/esm/languageLookups/querystring.js

@@ -0,0 +1,35 @@
+export default {
+  name: 'querystring',
+  lookup: function lookup(req, res, options) {
+    var found;
+
+    if (options.lookupQuerystring !== undefined && typeof req !== 'undefined') {
+      if (options.getQuery(req)) {
+        found = options.getQuery(req)[options.lookupQuerystring];
+      }
+
+      if (!found && options.getUrl(req) && options.getUrl(req).indexOf('?')) {
+        var lastPartOfUri = options.getUrl(req).substring(options.getUrl(req).indexOf('?'));
+
+        if (typeof URLSearchParams !== 'undefined') {
+          var urlParams = new URLSearchParams(lastPartOfUri);
+          found = urlParams.get(options.lookupQuerystring);
+        } else {
+          var indexOfQsStart = lastPartOfUri.indexOf("".concat(options.lookupQuerystring, "="));
+
+          if (indexOfQsStart > -1) {
+            var restOfUri = lastPartOfUri.substring(options.lookupQuerystring.length + 2);
+
+            if (restOfUri.indexOf('&') < 0) {
+              found = restOfUri;
+            } else {
+              found = restOfUri.substring(0, restOfUri.indexOf('&'));
+            }
+          }
+        }
+      }
+    }
+
+    return found;
+  }
+};

package/esm/languageLookups/session.js

@@ -0,0 +1,21 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+export default {
+  name: 'session',
+  lookup: function lookup(req, res, options) {
+    var found;
+
+    if (options.lookupSession !== undefined && _typeof(req) && options.getSession(req)) {
+      found = options.getSession(req)[options.lookupSession];
+    }
+
+    return found;
+  },
+  cacheUserLanguage: function cacheUserLanguage(req, res, lng) {
+    var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+    if (options.lookupSession && req && options.getSession(req)) {
+      options.getSession(req)[options.lookupSession] = lng;
+    }
+  }
+};

package/esm/utils.js

@@ -0,0 +1,55 @@
+export function setPath(object, path, newValue) {
+  var stack;
+  if (typeof path !== 'string') stack = [].concat(path);
+  if (typeof path === 'string') stack = path.split('.');
+
+  while (stack.length > 1) {
+    var _key = stack.shift();
+
+    if (_key.indexOf('###') > -1) _key = _key.replace(/###/g, '.');
+    if (!object[_key]) object[_key] = {};
+    object = object[_key];
+  }
+
+  var key = stack.shift();
+  if (key.indexOf('###') > -1) key = key.replace(/###/g, '.');
+  object[key] = newValue;
+}
+var arr = [];
+var each = arr.forEach;
+var slice = arr.slice;
+export function defaults(obj) {
+  each.call(slice.call(arguments, 1), function (source) {
+    if (source) {
+      for (var prop in source) {
+        if (obj[prop] === undefined) obj[prop] = source[prop];
+      }
+    }
+  });
+  return obj;
+}
+export function extend(obj) {
+  each.call(slice.call(arguments, 1), function (source) {
+    if (source) {
+      for (var prop in source) {
+        obj[prop] = source[prop];
+      }
+    }
+  });
+  return obj;
+}
+export function removeLngFromUrl(url, lookupFromPathIndex) {
+  var first = '';
+  var pos = lookupFromPathIndex;
+
+  if (url[0] === '/') {
+    pos++;
+    first = '/';
+  }
+
+  var parts = url.split('/');
+  parts.splice(pos, 1);
+  url = parts.join('/');
+  if (url[0] !== '/') url = first + url;
+  return url;
+}