locizify 5.0.0

package/example/node_modules/i18next-http-middleware/README.md

@@ -0,0 +1,380 @@
+# Introduction
+
+[![Actions](https://github.com/i18next/i18next-http-middleware/workflows/node/badge.svg)](https://github.com/i18next/i18next-http-middleware/actions?query=workflow%3Anode)
+[![Actions deno](https://github.com/i18next/i18next-http-middleware/workflows/deno/badge.svg)](https://github.com/i18next/i18next-http-middleware/actions?query=workflow%3Adeno)
+[![Travis](https://img.shields.io/travis/i18next/i18next-http-middleware/master.svg?style=flat-square)](https://travis-ci.org/i18next/i18next-http-middleware)
+[![npm version](https://img.shields.io/npm/v/i18next-http-middleware.svg?style=flat-square)](https://www.npmjs.com/package/i18next-http-middleware)
+
+
+This is a middleware to be used with Node.js web frameworks like express or Fastify and also for Deno.
+
+It's based on the deprecated [i18next-express-middleware](https://github.com/i18next/i18next-express-middleware) and can be used as a drop-in replacement.
+*It's not bound to a specific http framework anymore.*
+
+# Getting started
+
+```
+# npm package
+$ npm install i18next-http-middleware
+```
+
+## wire up i18next to request object
+
+```js
+var i18next = require('i18next')
+var middleware = require('i18next-http-middleware')
+var express = require('express')
+
+i18next.use(middleware.LanguageDetector).init({
+  preload: ['en', 'de', 'it'],
+  ...otherOptions
+})
+
+var app = express()
+app.use(
+  middleware.handle(i18next, {
+    ignoreRoutes: ['/foo'] // or function(req, res, options, i18next) { /* return true to ignore */ }
+  })
+)
+
+// in your request handler
+app.get('myRoute', (req, res) => {
+  var lng = req.language // 'de-CH'
+  var lngs = req.languages // ['de-CH', 'de', 'en']
+  req.i18n.changeLanguage('en') // will not load that!!! assert it was preloaded
+
+  var exists = req.i18n.exists('myKey')
+  var translation = req.t('myKey')
+})
+
+// in your views, eg. in pug (ex. jade)
+div = t('myKey')
+```
+
+### Fastify usage
+```js
+var i18next = require('i18next')
+var middleware = require('i18next-http-middleware')
+var fastify = require('fastify')
+
+i18next.use(middleware.LanguageDetector).init({
+  preload: ['en', 'de', 'it'],
+  ...otherOptions
+})
+
+var app = fastify()
+app.register(i18nextMiddleware.plugin, {
+  i18next,
+  ignoreRoutes: ['/foo'] // or function(req, res, options, i18next) { /* return true to ignore */ }
+})
+// or
+// app.addHook('preHandler', i18nextMiddleware.handle(i18next, {
+//   ignoreRoutes: ['/foo'] // or function(req, res, options, i18next) { /* return true to ignore */ }
+// }))
+
+// in your request handler
+app.get('myRoute', (request, reply) => {
+  var lng = request.language // 'de-CH'
+  var lngs = v.languages // ['de-CH', 'de', 'en']
+  request.i18n.changeLanguage('en') // will not load that!!! assert it was preloaded
+
+  var exists = request.i18n.exists('myKey')
+  var translation = request.t('myKey')
+})
+```
+
+### Deno usage
+
+#### abc
+
+```js
+import i18next from 'https://deno.land/x/i18next/index.js'
+import Backend from 'https://cdn.jsdelivr.net/gh/i18next/i18next-fs-backend/index.js'
+import i18nextMiddleware from 'https://deno.land/x/i18next_http_middleware/index.js'
+import { Application } from 'https://deno.land/x/abc/mod.ts'
+import { config } from "https://deno.land/x/dotenv/dotenv.ts";
+
+i18next
+  .use(Backend)
+  .use(i18nextMiddleware.LanguageDetector)
+  .init({
+    // debug: true,
+    backend: {
+      // eslint-disable-next-line no-path-concat
+      loadPath: 'locales/{{lng}}/{{ns}}.json',
+      // eslint-disable-next-line no-path-concat
+      addPath: 'locales/{{lng}}/{{ns}}.missing.json'
+    },
+    fallbackLng: 'en',
+    preload: ['en', 'de']
+  })
+
+const port = config.PORT || 8080
+const app = new Application()
+const handle = i18nextMiddleware.handle(i18next)
+app.use((next) =>
+  (c) => {
+    handle(c.request, c.response, () => {})
+    return next(c)
+  }
+)
+app.get('/', (c) => c.request.t('home.title'))
+await app.start({ port })
+```
+
+#### ServestJS
+
+```js
+import i18next from 'https://deno.land/x/i18next/index.js'
+import Backend from 'https://cdn.jsdelivr.net/gh/i18next/i18next-fs-backend/index.js'
+import i18nextMiddleware from 'https://deno.land/x/i18next_http_middleware/index.js'
+import { createApp } from 'https://servestjs.org/@v1.0.0-rc2/mod.ts'
+import { config } from "https://deno.land/x/dotenv/dotenv.ts";
+
+i18next
+  .use(Backend)
+  .use(i18nextMiddleware.LanguageDetector)
+  .init({
+    // debug: true,
+    backend: {
+      // eslint-disable-next-line no-path-concat
+      loadPath: 'locales/{{lng}}/{{ns}}.json',
+      // eslint-disable-next-line no-path-concat
+      addPath: 'locales/{{lng}}/{{ns}}.missing.json'
+    },
+    fallbackLng: 'en',
+    preload: ['en', 'de']
+  })
+
+const port = config.PORT || 8080
+const app = createApp()
+app.use(i18nextMiddleware.handle(i18next))
+app.get('/', async (req) => {
+  await req.respond({
+    status: 200,
+    headers: new Headers({
+      'content-type': 'text/plain',
+    }),
+    body: req.t('home.title')
+  })
+})
+await app.listen({ port })
+```
+
+## add routes
+
+```js
+// missing keys make sure the body is parsed (i.e. with [body-parser](https://github.com/expressjs/body-parser#bodyparserjsonoptions))
+app.post('/locales/add/:lng/:ns', middleware.missingKeyHandler(i18next))
+
+// multiload backend route
+app.get('/locales/resources.json', middleware.getResourcesHandler(i18next))
+```
+
+## add localized routes
+
+You can add your routes directly to the express app
+
+```js
+var express = require('express'),
+  app = express(),
+  i18next = require('i18next'),
+  FilesystemBackend = require('i18next-fs-backend'),
+  i18nextMiddleware = require('i18next-http-middleware'),
+  port = 3000
+
+i18next
+  .use(i18nextMiddleware.LanguageDetector)
+  .use(FilesystemBackend)
+  .init({ preload: ['en', 'de', 'it'], ...otherOptions }, () => {
+    i18nextMiddleware.addRoute(
+      i18next,
+      '/:lng/key-to-translate',
+      ['en', 'de', 'it'],
+      app,
+      'get',
+      (req, res) => {
+        //endpoint function
+      }
+    )
+  })
+app.use(i18nextMiddleware.handle(i18next))
+app.listen(port, () => {
+  console.log('Server listening on port', port)
+})
+```
+
+or to an express router
+
+```js
+var express = require('express'),
+  app = express(),
+  i18next = require('i18next'),
+  FilesystemBackend = require('i18next-fs-backend'),
+  i18nextMiddleware = require('i18next-http-middleware'),
+  router = require('express').Router(),
+  port = 3000
+
+i18next
+  .use(i18nextMiddleware.LanguageDetector)
+  .use(FilesystemBackend)
+  .init({ preload: ['en', 'de', 'it'], ...otherOptions }, () => {
+    i18nextMiddleware.addRoute(
+      i18next,
+      '/:lng/key-to-translate',
+      ['en', 'de', 'it'],
+      router,
+      'get',
+      (req, res) => {
+        //endpoint function
+      }
+    )
+    app.use('/', router)
+  })
+app.use(i18nextMiddleware.handle(i18next))
+app.listen(port, () => {
+  console.log('Server listening on port', port)
+})
+```
+
+## custom http server
+
+Define your own functions to handle your custom request or response
+
+```js
+middleware.handle(i18next, {
+  getPath: (req) => req.path,
+  getUrl: (req) => req.url,
+  setUrl: (req, url) => req.url = url,
+  getQuery: (req) => req.query,
+  getParams: (req) => req.params,
+  getBody: (req) => req.body,
+  setHeader: (res, name, value) => res.setHeader(name, value),
+  setContentType: (res, type) => res.contentType(type),
+  setStatus: (res, code) => res.status(code),
+  send: (res, body) => res.send(body)
+})
+```
+
+## language detection
+
+Detects user language from current request. Comes with support for:
+
+- path
+- cookie
+- header
+- querystring
+- session
+
+Wiring up:
+
+```js
+var i18next = require('i18next')
+var middleware = require('i18next-http-middleware')
+
+i18next.use(middleware.LanguageDetector).init(i18nextOptions)
+```
+
+As with all modules you can either pass the constructor function (class) to the i18next.use or a concrete instance.
+
+## Detector Options
+
+```js
+{
+  // order and from where user language should be detected
+  order: [/*'path', 'session', */ 'querystring', 'cookie', 'header'],
+
+  // keys or params to lookup language from
+  lookupQuerystring: 'lng',
+  lookupCookie: 'i18next',
+  lookupHeader: 'accept-language',
+  lookupSession: 'lng',
+  lookupPath: 'lng',
+  lookupFromPathIndex: 0,
+
+  // cache user language
+  caches: false, // ['cookie']
+
+  // optional expire and domain for set cookie
+  cookieExpirationDate: new Date(),
+  cookieDomain: 'myDomain',
+  cookiePath: '/my/path',
+  cookieSecure: true, // if need secure cookie
+  cookieSameSite: 'strict' // 'strict', 'lax' or 'none'
+}
+```
+
+Options can be passed in:
+
+**preferred** - by setting options.detection in i18next.init:
+
+```js
+var i18next = require('i18next')
+var middleware = require('i18next-http-middleware')
+
+i18next.use(middleware.LanguageDetector).init({
+  detection: options
+})
+```
+
+on construction:
+
+```js
+var middleware = require('i18next-http-middleware')
+var lngDetector = new middleware.LanguageDetector(null, options)
+```
+
+via calling init:
+
+```js
+var middleware = require('i18next-http-middleware')
+
+var lngDetector = new middleware.LanguageDetector()
+lngDetector.init(options)
+```
+
+## Adding own detection functionality
+
+### interface
+
+```js
+module.exports = {
+  name: 'myDetectorsName',
+
+  lookup: function(req, res, options) {
+    // options -> are passed in options
+    return 'en'
+  },
+
+  cacheUserLanguage: function(req, res, lng, options) {
+    // options -> are passed in options
+    // lng -> current language, will be called after init and on changeLanguage
+
+    // store it
+  }
+}
+```
+
+### adding it
+
+```js
+var i18next = require('i18next')
+var middleware = require('i18next-http-middleware')
+
+var lngDetector = new middleware.LanguageDetector()
+lngDetector.addDetector(myDetector)
+
+i18next.use(lngDetector).init({
+  detection: options
+})
+```
+
+---
+
+<h3 align='center'>Gold Sponsors</h3>
+
+<p align='center'>
+  <a href='https://locize.com/' target='_blank'>
+    <img src='https://raw.githubusercontent.com/i18next/i18next/master/assets/locize_sponsor_240.gif' width='240px'>
+  </a>
+</p>

package/example/node_modules/i18next-http-middleware/cjs/LanguageDetector.js

@@ -0,0 +1,150 @@
+"use strict";
+
+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); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var utils = _interopRequireWildcard(require("./utils.js"));
+
+var _cookie = _interopRequireDefault(require("./languageLookups/cookie.js"));
+
+var _querystring = _interopRequireDefault(require("./languageLookups/querystring.js"));
+
+var _path = _interopRequireDefault(require("./languageLookups/path.js"));
+
+var _header = _interopRequireDefault(require("./languageLookups/header.js"));
+
+var _session = _interopRequireDefault(require("./languageLookups/session.js"));
+
+var _httpFunctions = require("./httpFunctions.js");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function getDefaults() {
+  return (0, _httpFunctions.extendOptionsWithDefaults)({
+    order: [
+    /* 'path', 'session' */
+    'querystring', 'cookie', 'header'],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupSession: 'lng',
+    lookupFromPathIndex: 0,
+    // cache user language
+    caches: false,
+    // ['cookie']
+    // cookieExpirationDate: new Date(),
+    // cookieDomain: 'myDomain'
+    // cookiePath: '/my/path'
+    cookieSameSite: 'strict'
+  });
+}
+
+var LanguageDetector = /*#__PURE__*/function () {
+  function LanguageDetector(services) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+    _classCallCheck(this, LanguageDetector);
+
+    this.type = 'languageDetector';
+    this.detectors = {};
+    this.init(services, options, allOptions);
+  }
+
+  _createClass(LanguageDetector, [{
+    key: "init",
+    value: function init(services) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var allOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      this.services = services;
+      this.options = utils.defaults(options, this.options || {}, getDefaults());
+      this.allOptions = allOptions;
+      this.addDetector(_cookie["default"]);
+      this.addDetector(_querystring["default"]);
+      this.addDetector(_path["default"]);
+      this.addDetector(_header["default"]);
+      this.addDetector(_session["default"]);
+    }
+  }, {
+    key: "addDetector",
+    value: function addDetector(detector) {
+      this.detectors[detector.name] = detector;
+    }
+  }, {
+    key: "detect",
+    value: function detect(req, res, detectionOrder) {
+      var _this = this;
+
+      if (arguments.length < 2) return;
+      if (!detectionOrder) detectionOrder = this.options.order;
+      var found;
+      detectionOrder.forEach(function (detectorName) {
+        if (found || !_this.detectors[detectorName]) return;
+
+        var detections = _this.detectors[detectorName].lookup(req, res, _this.options);
+
+        if (!detections) return;
+        if (!Array.isArray(detections)) detections = [detections];
+
+        if (_this.services.languageUtils.getBestMatchFromCodes) {
+          // new i18next v19.5.0
+          found = _this.services.languageUtils.getBestMatchFromCodes(detections);
+          if (found) req.i18nextLookupName = detectorName;
+        } else {
+          found = detections.length > 0 ? detections[0] : null; // a little backward compatibility
+        }
+      });
+
+      if (!found) {
+        var fallbacks = this.allOptions.fallbackLng;
+        if (typeof fallbacks === 'string') fallbacks = [fallbacks];
+        if (!fallbacks) fallbacks = [];
+
+        if (Object.prototype.toString.apply(fallbacks) === '[object Array]') {
+          found = fallbacks[0];
+        } else {
+          found = fallbacks[0] || fallbacks["default"] && fallbacks["default"][0];
+        }
+      }
+
+      ;
+      return found;
+    }
+  }, {
+    key: "cacheUserLanguage",
+    value: function cacheUserLanguage(req, res, lng, caches) {
+      var _this2 = this;
+
+      if (arguments.length < 3) return;
+      if (!caches) caches = this.options.caches;
+      if (!caches) return;
+      caches.forEach(function (cacheName) {
+        if (_this2.detectors[cacheName] && _this2.detectors[cacheName].cacheUserLanguage && res.cachedUserLanguage !== lng) {
+          _this2.detectors[cacheName].cacheUserLanguage(req, res, lng, _this2.options);
+
+          res.cachedUserLanguage = lng;
+        }
+      });
+    }
+  }]);
+
+  return LanguageDetector;
+}();
+
+LanguageDetector.type = 'languageDetector';
+var _default = LanguageDetector;
+exports["default"] = _default;
+module.exports = exports.default;

package/example/node_modules/i18next-http-middleware/cjs/httpFunctions.js

@@ -0,0 +1,175 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.extendOptionsWithDefaults = exports.getSession = exports.send = exports.setStatus = exports.setContentType = exports.setHeader = exports.getHeader = exports.getBody = exports.getCookies = exports.getHeaders = exports.getParams = exports.getQuery = exports.getOriginalUrl = exports.setUrl = exports.getUrl = exports.getPath = void 0;
+
+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');
+};
+
+exports.getPath = getPath;
+
+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');
+};
+
+exports.getUrl = getUrl;
+
+var setUrl = function setUrl(req, url) {
+  if (req.url) {
+    req.url = url;
+    return;
+  }
+
+  console.log('no possibility found to get url');
+};
+
+exports.setUrl = setUrl;
+
+var getOriginalUrl = function getOriginalUrl(req) {
+  if (req.originalUrl) return req.originalUrl;
+  if (req.raw && req.raw.originalUrl) return req.raw.originalUrl;
+  return getUrl(req);
+};
+
+exports.getOriginalUrl = getOriginalUrl;
+
+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 {};
+};
+
+exports.getQuery = getQuery;
+
+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 {};
+};
+
+exports.getParams = getParams;
+
+var getHeaders = function getHeaders(req) {
+  if (req.headers) return req.headers;
+  console.log('no possibility found to get headers');
+};
+
+exports.getHeaders = getHeaders;
+
+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');
+};
+
+exports.getCookies = getCookies;
+
+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 {};
+};
+
+exports.getBody = getBody;
+
+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;
+};
+
+exports.getHeader = getHeader;
+
+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');
+};
+
+exports.setHeader = setHeader;
+
+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);
+};
+
+exports.setContentType = setContentType;
+
+var setStatus = function setStatus(res, code) {
+  if (typeof res.status === 'function') return res.status(code); // eslint-disable-next-line no-return-assign
+
+  if (res.status) return res.status = code;
+  console.log('no possibility found to set status');
+};
+
+exports.setStatus = setStatus;
+
+var send = function send(res, body) {
+  if (typeof res.send === 'function') return res.send(body);
+  return body;
+};
+
+exports.send = send;
+
+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');
+};
+
+exports.getSession = getSession;
+
+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;
+};
+
+exports.extendOptionsWithDefaults = extendOptionsWithDefaults;