use directories for structure

node_modules/i18next-scanner/lib/acorn-jsx-walk.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _acornWalk = require("acorn-walk");
+
+var _acornDynamicImport = require("acorn-dynamic-import");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+Object.assign(_acornWalk.base, _defineProperty({
+  FieldDefinition: function FieldDefinition(node, state, callback) {
+    if (node.value !== null) {
+      callback(node.value, state);
+    }
+  }
+}, _acornDynamicImport.DynamicImportKey, function () {})); // Extends acorn walk with JSX elements
+// https://github.com/RReverser/acorn-jsx/issues/23#issuecomment-403753801
+
+Object.assign(_acornWalk.base, {
+  JSXAttribute: function JSXAttribute(node, state, callback) {
+    if (node.value !== null) {
+      callback(node.value, state);
+    }
+  },
+  JSXElement: function JSXElement(node, state, callback) {
+    node.openingElement.attributes.forEach(function (attribute) {
+      callback(attribute, state);
+    });
+    node.children.forEach(function (node) {
+      callback(node, state);
+    });
+  },
+  JSXEmptyExpression: function JSXEmptyExpression(node, state, callback) {// Comments. Just ignore.
+  },
+  JSXExpressionContainer: function JSXExpressionContainer(node, state, callback) {
+    callback(node.expression, state);
+  },
+  JSXFragment: function JSXFragment(node, state, callback) {
+    node.children.forEach(function (node) {
+      callback(node, state);
+    });
+  },
+  JSXSpreadAttribute: function JSXSpreadAttribute(node, state, callback) {
+    callback(node.argument, state);
+  },
+  JSXText: function JSXText() {}
+});
+
+var _default = function _default(ast, options) {
+  (0, _acornWalk.simple)(ast, _objectSpread({}, options));
+};
+
+exports["default"] = _default;

node_modules/i18next-scanner/lib/flatten-object-keys.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+// flattenObjectKeys({
+//   a: {
+//     b: {
+//       c: [],
+//       d: {
+//         e: [{ f: [] }, { b: 1 }],
+//         g: {}
+//       }
+//     }
+//   }
+// });
+//
+// [ [ 'a', 'b', 'c' ],
+//   [ 'a', 'b', 'd', 'e', '0', 'f' ],
+//   [ 'a', 'b', 'd', 'e', '1', 'b' ],
+//   [ 'a', 'b', 'd', 'g' ] ]
+//
+var flattenObjectKeys = function flattenObjectKeys(obj) {
+  var keys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return Object.keys(obj).reduce(function (acc, key) {
+    var o = (0, _isPlainObject["default"])(obj[key]) && Object.keys(obj[key]).length > 0 || Array.isArray(obj[key]) && obj[key].length > 0 ? flattenObjectKeys(obj[key], keys.concat(key)) : [keys.concat(key)];
+    return acc.concat(o);
+  }, []);
+};
+
+var _default = flattenObjectKeys;
+exports["default"] = _default;

node_modules/i18next-scanner/lib/index.js

@@ -0,0 +1,147 @@
+"use strict";
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _eol = _interopRequireDefault(require("eol"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _includes = _interopRequireDefault(require("lodash/includes"));
+
+var _vinyl = _interopRequireDefault(require("vinyl"));
+
+var _through = _interopRequireDefault(require("through2"));
+
+var _parser = _interopRequireDefault(require("./parser"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/* eslint-disable no-buffer-constructor */
+var transform = function transform(parser, customTransform) {
+  return function _transform(file, enc, done) {
+    var options = parser.options;
+
+    var content = _fs["default"].readFileSync(file.path, enc);
+
+    var extname = _path["default"].extname(file.path);
+
+    if ((0, _includes["default"])((0, _get["default"])(options, 'attr.extensions'), extname)) {
+      // Parse attribute (e.g. data-i18n="key")
+      parser.parseAttrFromString(content, {
+        transformOptions: {
+          filepath: file.path
+        }
+      });
+    }
+
+    if ((0, _includes["default"])((0, _get["default"])(options, 'func.extensions'), extname)) {
+      // Parse translation function (e.g. i18next.t('key'))
+      parser.parseFuncFromString(content, {
+        transformOptions: {
+          filepath: file.path
+        }
+      });
+    }
+
+    if ((0, _includes["default"])((0, _get["default"])(options, 'trans.extensions'), extname)) {
+      // Look for Trans components in JSX
+      parser.parseTransFromString(content, {
+        transformOptions: {
+          filepath: file.path
+        }
+      });
+    }
+
+    if (typeof customTransform === 'function') {
+      this.parser = parser;
+      customTransform.call(this, file, enc, done);
+      return;
+    }
+
+    done();
+  };
+};
+
+var flush = function flush(parser, customFlush) {
+  return function _flush(done) {
+    var _this = this;
+
+    var options = parser.options;
+
+    if (typeof customFlush === 'function') {
+      this.parser = parser;
+      customFlush.call(this, done);
+      return;
+    } // Flush to resource store
+
+
+    var resStore = parser.get({
+      sort: options.sort
+    });
+    var jsonIndent = options.resource.jsonIndent;
+    var lineEnding = String(options.resource.lineEnding).toLowerCase();
+    Object.keys(resStore).forEach(function (lng) {
+      var namespaces = resStore[lng];
+      Object.keys(namespaces).forEach(function (ns) {
+        var obj = namespaces[ns];
+        var resPath = parser.formatResourceSavePath(lng, ns);
+        var text = JSON.stringify(obj, null, jsonIndent) + '\n';
+
+        if (lineEnding === 'auto') {
+          text = _eol["default"].auto(text);
+        } else if (lineEnding === '\r\n' || lineEnding === 'crlf') {
+          text = _eol["default"].crlf(text);
+        } else if (lineEnding === '\n' || lineEnding === 'lf') {
+          text = _eol["default"].lf(text);
+        } else if (lineEnding === '\r' || lineEnding === 'cr') {
+          text = _eol["default"].cr(text);
+        } else {
+          // Defaults to LF
+          text = _eol["default"].lf(text);
+        }
+
+        var contents = null;
+
+        try {
+          // "Buffer.from(string[, encoding])" is added in Node.js v5.10.0
+          contents = Buffer.from(text);
+        } catch (e) {
+          // Fallback to "new Buffer(string[, encoding])" which is deprecated since Node.js v6.0.0
+          contents = new Buffer(text);
+        }
+
+        _this.push(new _vinyl["default"]({
+          path: resPath,
+          contents: contents
+        }));
+      });
+    });
+    done();
+  };
+}; // @param {object} options The options object.
+// @param {function} [customTransform]
+// @param {function} [customFlush]
+// @return {object} Returns a through2.obj().
+
+
+var createStream = function createStream(options, customTransform, customFlush) {
+  var parser = new _parser["default"](options);
+
+  var stream = _through["default"].obj(transform(parser, customTransform), flush(parser, customFlush));
+
+  return stream;
+}; // Convenience API
+
+
+module.exports = function () {
+  var _module$exports;
+
+  return (_module$exports = module.exports).createStream.apply(_module$exports, arguments);
+}; // Basic API
+
+
+module.exports.createStream = createStream; // Parser
+
+module.exports.Parser = _parser["default"];

node_modules/i18next-scanner/lib/nodes-to-string.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _get2 = _interopRequireDefault(require("lodash/get"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isJSXText = function isJSXText(node) {
+  if (!node) {
+    return false;
+  }
+
+  return node.type === 'JSXText';
+};
+
+var isNumericLiteral = function isNumericLiteral(node) {
+  if (!node) {
+    return false;
+  }
+
+  return node.type === 'Literal' && typeof node.value === 'number';
+};
+
+var isStringLiteral = function isStringLiteral(node) {
+  if (!node) {
+    return false;
+  }
+
+  return node.type === 'Literal' && typeof node.value === 'string';
+};
+
+var isObjectExpression = function isObjectExpression(node) {
+  if (!node) {
+    return false;
+  }
+
+  return node.type === 'ObjectExpression';
+};
+
+var nodesToString = function nodesToString(nodes) {
+  var memo = '';
+  var nodeIndex = 0;
+  nodes.forEach(function (node, i) {
+    if (isJSXText(node) || isStringLiteral(node)) {
+      var value = node.value.replace(/^[\r\n]+\s*/g, '') // remove leading spaces containing a leading newline character
+      .replace(/[\r\n]+\s*$/g, '') // remove trailing spaces containing a leading newline character
+      .replace(/[\r\n]+\s*/g, ' '); // replace spaces containing a leading newline character with a single space character
+
+      if (!value) {
+        return;
+      }
+
+      memo += value;
+    } else if (node.type === 'JSXExpressionContainer') {
+      var _node$expression = node.expression,
+          expression = _node$expression === void 0 ? {} : _node$expression;
+
+      if (isNumericLiteral(expression)) {
+        // Numeric literal is ignored in react-i18next
+        memo += '';
+      }
+
+      if (isStringLiteral(expression)) {
+        memo += expression.value;
+      } else if (isObjectExpression(expression) && (0, _get2["default"])(expression, 'properties[0].type') === 'Property') {
+        memo += "<".concat(nodeIndex, ">{{").concat(expression.properties[0].key.name, "}}</").concat(nodeIndex, ">");
+      } else {
+        console.error("Unsupported JSX expression. Only static values or {{interpolation}} blocks are supported. Got ".concat(expression.type, ":"));
+        console.error(node.expression);
+      }
+    } else if (node.children) {
+      memo += "<".concat(nodeIndex, ">").concat(nodesToString(node.children), "</").concat(nodeIndex, ">");
+    }
+
+    ++nodeIndex;
+  });
+  return memo;
+};
+
+var _default = nodesToString;
+exports["default"] = _default;

node_modules/i18next-scanner/lib/omit-empty-object.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _isPlainObject = _interopRequireDefault(require("lodash/isPlainObject"));
+
+var _cloneDeep = _interopRequireDefault(require("clone-deep"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+// omitEmptyObject({
+//   a: {
+//     b: {
+//       c: 1,
+//       d: {
+//         e: {
+//         }
+//       }
+//     }
+//   }
+// });
+//
+// { a: { b: { c: 1 } } }
+//
+var unsetEmptyObject = function unsetEmptyObject(obj) {
+  Object.keys(obj).forEach(function (key) {
+    if (!(0, _isPlainObject["default"])(obj[key])) {
+      return;
+    }
+
+    unsetEmptyObject(obj[key]);
+
+    if ((0, _isPlainObject["default"])(obj[key]) && Object.keys(obj[key]).length === 0) {
+      obj[key] = undefined;
+      delete obj[key];
+    }
+  });
+  return obj;
+};
+
+var omitEmptyObject = function omitEmptyObject(obj) {
+  return unsetEmptyObject((0, _cloneDeep["default"])(obj));
+};
+
+var _default = omitEmptyObject;
+exports["default"] = _default;