@lingui/macro 3.14.0 → 3.16.0

package/build/macroJsx.js

@@ -0,0 +1,328 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeWhitespace = normalizeWhitespace;
+exports.default = void 0;
+
+var R = _interopRequireWildcard(require("ramda"));
+
+var _icu = _interopRequireDefault(require("./icu"));
+
+var _utils = require("./utils");
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { 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; }
+
+const pluralRuleRe = /(_[\d\w]+|zero|one|two|few|many|other)/;
+
+const jsx2icuExactChoice = value => value.replace(/_(\d+)/, "=$1").replace(/_(\w+)/, "$1"); // replace whitespace before/after newline with single space
+
+
+const keepSpaceRe = /\s*(?:\r\n|\r|\n)+\s*/g; // remove whitespace before/after tag or expression
+
+const stripAroundTagsRe = /(?:([>}])(?:\r\n|\r|\n)+\s*|(?:\r\n|\r|\n)+\s*(?=[<{]))/g;
+
+function maybeNodeValue(node) {
+  if (!node) return null;
+  if (node.type === "StringLiteral") return node.value;
+  if (node.type === "JSXAttribute") return maybeNodeValue(node.value);
+  if (node.type === "JSXExpressionContainer") return maybeNodeValue(node.expression);
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0].value.raw;
+  return null;
+}
+
+function normalizeWhitespace(text) {
+  return text.replace(stripAroundTagsRe, "$1").replace(keepSpaceRe, " ") // keep escaped newlines
+  .replace(/\\n/g, "\n").replace(/\\s/g, " ") // we remove trailing whitespace inside Plural
+  .replace(/(\s+})/gm, "}").trim();
+}
+
+class MacroJSX {
+  expressionIndex = (0, _utils.makeCounter)();
+  elementIndex = (0, _utils.makeCounter)();
+
+  constructor({
+    types
+  }) {
+    this.types = types;
+  }
+
+  safeJsxAttribute = (name, value) => {
+    // This handles quoted JSX attributes and html entities.
+    return this.types.jsxAttribute(this.types.jsxIdentifier(name), this.types.jsxExpressionContainer(this.types.stringLiteral(value)));
+  };
+  replacePath = path => {
+    const tokens = this.tokenizeNode(path.node);
+    const messageFormat = new _icu.default();
+    const {
+      message: messageRaw,
+      values,
+      jsxElements
+    } = messageFormat.fromTokens(tokens);
+    const message = normalizeWhitespace(messageRaw);
+    const {
+      attributes,
+      id,
+      comment,
+      context
+    } = this.stripMacroAttributes(path.node);
+
+    if (!id && !message) {
+      return;
+    } else if (id && id !== message) {
+      // If `id` prop already exists and generated ID is different,
+      // add it as a `default` prop
+      attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier(_constants.ID), this.types.stringLiteral(id)));
+
+      if (process.env.NODE_ENV !== "production") {
+        if (message) {
+          attributes.push(this.safeJsxAttribute(_constants.MESSAGE, message));
+        }
+      }
+    } else {
+      attributes.push(this.safeJsxAttribute(_constants.ID, message));
+    }
+
+    if (process.env.NODE_ENV !== "production") {
+      if (comment) {
+        attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier(_constants.COMMENT), this.types.stringLiteral(comment)));
+      }
+    }
+
+    if (context) {
+      attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier(_constants.CONTEXT), this.types.stringLiteral(context)));
+    } // Parameters for variable substitution
+
+
+    const valuesObject = Object.keys(values).map(key => this.types.objectProperty(this.types.identifier(key), values[key]));
+
+    if (valuesObject.length) {
+      attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier("values"), this.types.jsxExpressionContainer(this.types.objectExpression(valuesObject))));
+    } // Inline elements
+
+
+    if (Object.keys(jsxElements).length) {
+      attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier("components"), this.types.jsxExpressionContainer(this.types.objectExpression(Object.keys(jsxElements).map(key => this.types.objectProperty(this.types.identifier(key), jsxElements[key]))))));
+    }
+
+    const newNode = this.types.jsxElement(this.types.jsxOpeningElement(this.types.jsxIdentifier("Trans"), attributes,
+    /*selfClosing*/
+    true),
+    /*closingElement*/
+    null,
+    /*children*/
+    [],
+    /*selfClosing*/
+    true);
+    newNode.loc = path.node.loc;
+    path.replaceWith(newNode);
+  };
+  attrName = (names, exclude = false) => {
+    const namesRe = new RegExp("^(" + names.join("|") + ")$");
+    return attr => {
+      const name = attr.name.name;
+      return exclude ? !namesRe.test(name) : namesRe.test(name);
+    };
+  };
+  stripMacroAttributes = node => {
+    const {
+      attributes
+    } = node.openingElement;
+    const id = attributes.filter(this.attrName([_constants.ID]))[0];
+    const message = attributes.filter(this.attrName([_constants.MESSAGE]))[0];
+    const comment = attributes.filter(this.attrName([_constants.COMMENT]))[0];
+    const context = attributes.filter(this.attrName([_constants.CONTEXT]))[0];
+    let reserved = [_constants.ID, _constants.MESSAGE, _constants.COMMENT, _constants.CONTEXT];
+
+    if (this.isI18nComponent(node)) {// no reserved prop names
+    } else if (this.isChoiceComponent(node)) {
+      reserved = [...reserved, "_\\w+", "_\\d+", "zero", "one", "two", "few", "many", "other", "value", "offset"];
+    }
+
+    return {
+      id: maybeNodeValue(id),
+      message: maybeNodeValue(message),
+      comment: maybeNodeValue(comment),
+      context: maybeNodeValue(context),
+      attributes: attributes.filter(this.attrName(reserved, true))
+    };
+  };
+  tokenizeNode = node => {
+    if (this.isI18nComponent(node)) {
+      // t
+      return this.tokenizeTrans(node);
+    } else if (this.isChoiceComponent(node)) {
+      // plural, select and selectOrdinal
+      return this.tokenizeChoiceComponent(node);
+    } else if (this.types.isJSXElement(node)) {
+      return this.tokenizeElement(node);
+    } else {
+      return this.tokenizeExpression(node);
+    }
+  };
+  tokenizeTrans = node => {
+    return R.flatten(node.children.map(child => this.tokenizeChildren(child)).filter(Boolean));
+  };
+  tokenizeChildren = node => {
+    if (this.types.isJSXExpressionContainer(node)) {
+      const exp = node.expression;
+
+      if (this.types.isStringLiteral(exp)) {
+        // Escape forced newlines to keep them in message.
+        return {
+          type: "text",
+          value: exp.value.replace(/\n/g, "\\n")
+        };
+      } else if (this.types.isTemplateLiteral(exp)) {
+        const tokenize = R.pipe( // Don"t output tokens without text.
+        R.evolve({
+          quasis: R.map(text => {
+            // if it's an unicode we keep the cooked value because it's the parsed value by babel (without unicode chars)
+            // This regex will detect if a string contains unicode chars, when they're we should interpolate them
+            // why? because platforms like react native doesn't parse them, just doing a JSON.parse makes them UTF-8 friendly
+            const value = /\\u[a-fA-F0-9]{4}|\\x[a-fA-F0-9]{2}/g.test(text.value.raw) ? text.value.cooked : text.value.raw;
+            if (value === "") return null;
+            return this.tokenizeText(this.clearBackslashes(value));
+          }),
+          expressions: R.map(exp => this.types.isCallExpression(exp) ? this.tokenizeNode(exp) : this.tokenizeExpression(exp))
+        }), exp => (0, _utils.zip)(exp.quasis, exp.expressions), R.flatten, R.filter(Boolean));
+        return tokenize(exp);
+      } else if (this.types.isJSXElement(exp)) {
+        return this.tokenizeNode(exp);
+      } else {
+        return this.tokenizeExpression(exp);
+      }
+    } else if (this.types.isJSXElement(node)) {
+      return this.tokenizeNode(node);
+    } else if (this.types.isJSXSpreadChild(node)) {// just do nothing
+    } else if (this.types.isJSXText(node)) {
+      return this.tokenizeText(node.value);
+    } else {// impossible path
+      // return this.tokenizeText(node.value)
+    }
+  };
+  tokenizeChoiceComponent = node => {
+    const element = node.openingElement;
+    const format = this.getJsxTagName(node).toLowerCase();
+    const props = element.attributes.filter(this.attrName([_constants.ID, _constants.COMMENT, _constants.MESSAGE, _constants.CONTEXT, "key", // we remove <Trans /> react props that are not useful for translation
+    "render", "component", "components"], true));
+    const token = {
+      type: "arg",
+      format,
+      name: null,
+      value: undefined,
+      options: {
+        offset: undefined
+      }
+    };
+
+    for (const attr of props) {
+      if (this.types.isJSXSpreadAttribute(attr)) {
+        continue;
+      }
+
+      if (this.types.isJSXNamespacedName(attr.name)) {
+        continue;
+      }
+
+      const name = attr.name.name;
+
+      if (name === "value") {
+        const exp = this.types.isLiteral(attr.value) ? attr.value : attr.value.expression;
+        token.name = this.expressionToArgument(exp);
+        token.value = exp;
+      } else if (format !== "select" && name === "offset") {
+        // offset is static parameter, so it must be either string or number
+        token.options.offset = this.types.isStringLiteral(attr.value) ? attr.value.value : attr.value.expression.value;
+      } else {
+        let value;
+
+        if (this.types.isStringLiteral(attr.value)) {
+          value = attr.value.extra.raw.replace(/(["'])(.*)\1/, "$2");
+        } else {
+          value = this.tokenizeChildren(attr.value);
+        }
+
+        if (pluralRuleRe.test(name)) {
+          token.options[jsx2icuExactChoice(name)] = value;
+        } else {
+          token.options[name] = value;
+        }
+      }
+    }
+
+    return token;
+  };
+  tokenizeElement = node => {
+    // !!! Important: Calculate element index before traversing children.
+    // That way outside elements are numbered before inner elements. (...and it looks pretty).
+    const name = this.elementIndex();
+    const children = R.flatten(node.children.map(child => this.tokenizeChildren(child)).filter(Boolean));
+    node.children = [];
+    node.openingElement.selfClosing = true;
+    return {
+      type: "element",
+      name,
+      value: node,
+      children
+    };
+  };
+  tokenizeExpression = node => {
+    return {
+      type: "arg",
+      name: this.expressionToArgument(node),
+      value: node
+    };
+  };
+  tokenizeText = value => {
+    return {
+      type: "text",
+      value
+    };
+  };
+
+  expressionToArgument(exp) {
+    return this.types.isIdentifier(exp) ? exp.name : String(this.expressionIndex());
+  }
+  /**
+   * We clean '//\` ' to just '`'
+   **/
+
+
+  clearBackslashes(value) {
+    // if not we replace the extra scaped literals
+    return value.replace(/\\`/g, "`");
+  }
+  /**
+   * Custom matchers
+   */
+
+
+  isIdentifier = (node, name) => {
+    return this.types.isIdentifier(node, {
+      name
+    });
+  };
+  isI18nComponent = (node, name = "Trans") => {
+    return this.types.isJSXElement(node) && this.types.isJSXIdentifier(node.openingElement.name, {
+      name
+    });
+  };
+  isChoiceComponent = node => {
+    return this.isI18nComponent(node, "Plural") || this.isI18nComponent(node, "Select") || this.isI18nComponent(node, "SelectOrdinal");
+  };
+  getJsxTagName = node => {
+    if (this.types.isJSXIdentifier(node.openingElement.name)) {
+      return node.openingElement.name.name;
+    }
+  };
+}
+
+exports.default = MacroJSX;

package/build/utils.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.zip = zip;
+exports.makeCounter = void 0;
+
+var R = _interopRequireWildcard(require("ramda"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { 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; }
+
+/**
+ * Custom zip method which takes length of the larger array
+ * (usually zip functions use the `smaller` length, discarding values in larger array)
+ */
+function zip(a, b) {
+  return R.range(0, Math.max(a.length, b.length)).map(index => [a[index], b[index]]);
+}
+
+const makeCounter = (index = 0) => () => index++;
+
+exports.makeCounter = makeCounter;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@lingui/macro",
-  "version": "3.14.0",
+  "version": "3.16.0",
   "description": "Macro for generating messages in ICU MessageFormat syntax",
-  "main": "index.js",
+  "main": "./build/index.js",
   "author": {
     "name": "Tomáš Ehrlich",
     "email": "tomas.ehrlich@gmail.com"
@@ -19,23 +19,25 @@
     "url": "https://github.com/lingui/js-lingui/issues"
   },
   "engines": {
-    "node": ">=10.0.0"
+    "node": ">=14.0.0"
   },
   "files": [
     "LICENSE",
     "README.md",
-    "*.js",
-    "global.d.ts",
-    "index.d.ts"
+    "build/"
   ],
   "dependencies": {
     "@babel/runtime": "^7.11.2",
-    "@lingui/conf": "^3.14.0",
+    "@lingui/conf": "3.16.0",
     "ramda": "^0.27.1"
   },
   "peerDependencies": {
     "@lingui/core": "^3.13.0",
     "@lingui/react": "^3.13.0",
-    "babel-plugin-macros": "2 || 3"
-  }
+    "babel-plugin-macros": "2 || 3"
+  },
+  "devDependencies": {
+    "@types/babel-plugin-macros": "^2.8.5"
+  },
+  "gitHead": "e8c1f518b988f45f3f6da84333550b215dcde94b"
 }

package/icu.js

@@ -1,118 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = ICUMessageFormat;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-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) { (0, _defineProperty2.default)(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; }
-
-var metaOptions = ["id", "comment", "props"];
-var escapedMetaOptionsRe = new RegExp("^_(".concat(metaOptions.join("|"), ")$"));
-
-function ICUMessageFormat() {}
-
-ICUMessageFormat.prototype.fromTokens = function (tokens) {
-  var _this = this;
-
-  return (Array.isArray(tokens) ? tokens : [tokens]).map(function (token) {
-    return _this.processToken(token);
-  }).filter(Boolean).reduce(function (props, message) {
-    return _objectSpread(_objectSpread({}, message), {}, {
-      message: props.message + message.message,
-      values: _objectSpread(_objectSpread({}, props.values), message.values),
-      jsxElements: _objectSpread(_objectSpread({}, props.jsxElements), message.jsxElements)
-    });
-  }, {
-    message: "",
-    values: {},
-    jsxElements: {}
-  });
-};
-
-ICUMessageFormat.prototype.processToken = function (token) {
-  var _this2 = this;
-
-  var jsxElements = {};
-
-  if (token.type === "text") {
-    return {
-      message: token.value
-    };
-  } else if (token.type === "arg") {
-    if (token.value !== undefined && token.value.type === 'JSXEmptyExpression') {
-      return null;
-    }
-
-    var values = token.value !== undefined ? (0, _defineProperty2.default)({}, token.name, token.value) : {};
-
-    switch (token.format) {
-      case "plural":
-      case "select":
-      case "selectordinal":
-        var formatOptions = Object.keys(token.options).filter(function (key) {
-          return token.options[key] != null;
-        }).map(function (key) {
-          var value = token.options[key];
-          key = key.replace(escapedMetaOptionsRe, "$1");
-
-          if (key === "offset") {
-            // offset has special syntax `offset:number`
-            return "offset:".concat(value);
-          }
-
-          if (typeof value !== "string") {
-            // process tokens from nested formatters
-            var _this2$fromTokens = _this2.fromTokens(value),
-                message = _this2$fromTokens.message,
-                childValues = _this2$fromTokens.values,
-                childJsxElements = _this2$fromTokens.jsxElements;
-
-            Object.assign(values, childValues);
-            Object.assign(jsxElements, childJsxElements);
-            value = message;
-          }
-
-          return "".concat(key, " {").concat(value, "}");
-        }).join(" ");
-        return {
-          message: "{".concat(token.name, ", ").concat(token.format, ", ").concat(formatOptions, "}"),
-          values: values,
-          jsxElements: jsxElements
-        };
-
-      default:
-        return {
-          message: "{".concat(token.name, "}"),
-          values: values
-        };
-    }
-  } else if (token.type === "element") {
-    var message = "";
-    var elementValues = {};
-    Object.assign(jsxElements, (0, _defineProperty2.default)({}, token.name, token.value));
-    token.children.forEach(function (child) {
-      var _this2$fromTokens2 = _this2.fromTokens(child),
-          childMessage = _this2$fromTokens2.message,
-          childValues = _this2$fromTokens2.values,
-          childJsxElements = _this2$fromTokens2.jsxElements;
-
-      message += childMessage;
-      Object.assign(elementValues, childValues);
-      Object.assign(jsxElements, childJsxElements);
-    });
-    return {
-      message: token.children.length ? "<".concat(token.name, ">").concat(message, "</").concat(token.name, ">") : "<".concat(token.name, "/>"),
-      values: elementValues,
-      jsxElements: jsxElements
-    };
-  }
-
-  throw new Error("Unknown token type ".concat(token.type));
-};

package/index.js

@@ -1,168 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _babelPluginMacros = require("babel-plugin-macros");
-
-var _conf = require("@lingui/conf");
-
-var _macroJs = _interopRequireDefault(require("./macroJs"));
-
-var _macroJsx = _interopRequireDefault(require("./macroJsx"));
-
-var config = (0, _conf.getConfig)({
-  configPath: process.env.LINGUI_CONFIG
-});
-
-var getSymbolSource = function getSymbolSource(name) {
-  if (Array.isArray(config.runtimeConfigModule)) {
-    if (name === "i18n") {
-      return config.runtimeConfigModule;
-    } else {
-      return ["@lingui/react", name];
-    }
-  } else {
-    if (Object.prototype.hasOwnProperty.call(config.runtimeConfigModule, name)) {
-      return config.runtimeConfigModule[name];
-    } else {
-      return ["@lingui/react", name];
-    }
-  }
-};
-
-var _getSymbolSource = getSymbolSource("i18n"),
-    _getSymbolSource2 = (0, _slicedToArray2.default)(_getSymbolSource, 2),
-    i18nImportModule = _getSymbolSource2[0],
-    _getSymbolSource2$ = _getSymbolSource2[1],
-    i18nImportName = _getSymbolSource2$ === void 0 ? "i18n" : _getSymbolSource2$;
-
-var _getSymbolSource3 = getSymbolSource("Trans"),
-    _getSymbolSource4 = (0, _slicedToArray2.default)(_getSymbolSource3, 2),
-    TransImportModule = _getSymbolSource4[0],
-    _getSymbolSource4$ = _getSymbolSource4[1],
-    TransImportName = _getSymbolSource4$ === void 0 ? "Trans" : _getSymbolSource4$;
-
-function macro(_ref) {
-  var references = _ref.references,
-      state = _ref.state,
-      babel = _ref.babel;
-  var jsxNodes = [];
-  var jsNodes = [];
-  var needsI18nImport = false;
-  Object.keys(references).forEach(function (tagName) {
-    var nodes = references[tagName];
-    var macroType = getMacroType(tagName);
-
-    if (macroType == null) {
-      throw nodes[0].buildCodeFrameError("Unknown macro ".concat(tagName));
-    }
-
-    if (macroType === "js") {
-      nodes.forEach(function (node) {
-        jsNodes.push(node.parentPath);
-      });
-    } else {
-      nodes.forEach(function (node) {
-        // identifier.openingElement.jsxElement
-        jsxNodes.push(node.parentPath.parentPath);
-      });
-    }
-  });
-  jsNodes.filter(isRootPath(jsNodes)).forEach(function (path) {
-    if (alreadyVisited(path)) return;
-    var macro = new _macroJs.default(babel, {
-      i18nImportName: i18nImportName
-    });
-    if (macro.replacePath(path)) needsI18nImport = true;
-  });
-  jsxNodes.filter(isRootPath(jsxNodes)).forEach(function (path) {
-    if (alreadyVisited(path)) return;
-    var macro = new _macroJsx.default(babel);
-    macro.replacePath(path);
-  });
-
-  if (needsI18nImport) {
-    addImport(babel, state, i18nImportModule, i18nImportName);
-  }
-
-  if (jsxNodes.length) {
-    addImport(babel, state, TransImportModule, TransImportName);
-  }
-
-  if (process.env.LINGUI_EXTRACT === "1") {
-    return {
-      keepImports: true
-    };
-  }
-}
-
-function addImport(babel, state, module, importName) {
-  var t = babel.types;
-  var linguiImport = state.file.path.node.body.find(function (importNode) {
-    return t.isImportDeclaration(importNode) && importNode.source.value === module && // https://github.com/lingui/js-lingui/issues/777
-    importNode.importKind !== "type";
-  });
-  var tIdentifier = t.identifier(importName); // Handle adding the import or altering the existing import
-
-  if (linguiImport) {
-    if (linguiImport.specifiers.findIndex(function (specifier) {
-      return specifier.imported && specifier.imported.name === importName;
-    }) === -1) {
-      linguiImport.specifiers.push(t.importSpecifier(tIdentifier, tIdentifier));
-    }
-  } else {
-    state.file.path.node.body.unshift(t.importDeclaration([t.importSpecifier(tIdentifier, tIdentifier)], t.stringLiteral(module)));
-  }
-}
-
-function isRootPath(allPath) {
-  return function (node) {
-    return function traverse(path) {
-      if (!path.parentPath) {
-        return true;
-      } else {
-        return !allPath.includes(path.parentPath) && traverse(path.parentPath);
-      }
-    }(node);
-  };
-}
-
-var alreadyVisitedCache = [];
-
-function alreadyVisited(path) {
-  if (alreadyVisitedCache.includes(path)) {
-    return true;
-  } else {
-    alreadyVisitedCache.push(path);
-    return false;
-  }
-}
-
-function getMacroType(tagName) {
-  switch (tagName) {
-    case "defineMessage":
-    case "arg":
-    case "t":
-    case "plural":
-    case "select":
-    case "selectOrdinal":
-      return "js";
-
-    case "Trans":
-    case "Plural":
-    case "Select":
-    case "SelectOrdinal":
-      return "jsx";
-  }
-}
-
-var _default = (0, _babelPluginMacros.createMacro)(macro);
-
-exports.default = _default;