@lingui/macro 4.0.0-next.3 → 4.0.0-next.5

package/build/macroJs.js

@@ -1,340 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _types = require("@babel/types");
-var _icu = _interopRequireDefault(require("./icu"));
-var _utils = require("./utils");
-var _constants = require("./constants");
-var _api = require("@lingui/cli/api");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-const keepSpaceRe = /(?:\\(?:\r\n|\r|\n))+\s+/g;
-const keepNewLineRe = /(?:\r\n|\r|\n)+\s+/g;
-function normalizeWhitespace(text) {
-  return text.replace(keepSpaceRe, " ").replace(keepNewLineRe, "\n").trim();
-}
-function buildICUFromTokens(tokens) {
-  const messageFormat = new _icu.default();
-  const {
-    message,
-    values
-  } = messageFormat.fromTokens(tokens);
-  return {
-    message: normalizeWhitespace(message),
-    values
-  };
-}
-class MacroJs {
-  // Babel Types
-
-  // Identifier of i18n object
-
-  // Positional expressions counter (e.g. for placeholders `Hello {0}, today is {1}`)
-  _expressionIndex = (0, _utils.makeCounter)();
-  constructor({
-    types
-  }, opts) {
-    this.types = types;
-    this.i18nImportName = opts.i18nImportName;
-    this.stripNonEssentialProps = opts.stripNonEssentialProps;
-    this.nameMap = opts.nameMap;
-    this.nameMapReversed = Array.from(opts.nameMap.entries()).reduce((map, [key, value]) => map.set(value, key), new Map());
-  }
-  replacePathWithMessage = (path, tokens, linguiInstance) => {
-    const newNode = this.createI18nCall(this.createMessageDescriptorFromTokens(tokens, path.node.loc), linguiInstance);
-    path.replaceWith(newNode);
-  };
-
-  // Returns a boolean indicating if the replacement requires i18n import
-  replacePath = path => {
-    // reset the expression counter
-    this._expressionIndex = (0, _utils.makeCounter)();
-
-    // defineMessage({ message: "Message", context: "My" }) -> {id: <hash + context>, message: "Message"}
-    if (this.types.isCallExpression(path.node) && this.isDefineMessage(path.node.callee)) {
-      let descriptor = this.processDescriptor(path.node.arguments[0]);
-      path.replaceWith(descriptor);
-      return false;
-    }
-
-    // defineMessage`Message` -> {id: <hash>, message: "Message"}
-    if (this.types.isTaggedTemplateExpression(path.node) && this.isDefineMessage(path.node.tag)) {
-      const tokens = this.tokenizeTemplateLiteral(path.node.quasi);
-      const descriptor = this.createMessageDescriptorFromTokens(tokens, path.node.loc);
-      path.replaceWith(descriptor);
-      return false;
-    }
-
-    // t(i18nInstance)`Message` -> i18nInstance._(messageDescriptor)
-    if (this.types.isCallExpression(path.node) && this.types.isTaggedTemplateExpression(path.parentPath.node) && this.types.isExpression(path.node.arguments[0]) && this.isLinguiIdentifier(path.node.callee, "t")) {
-      // Use the first argument as i18n instance instead of the default i18n instance
-      const i18nInstance = path.node.arguments[0];
-      const tokens = this.tokenizeNode(path.parentPath.node);
-      this.replacePathWithMessage(path.parentPath, tokens, i18nInstance);
-      return false;
-    }
-
-    // t(i18nInstance)(messageDescriptor) -> i18nInstance._(messageDescriptor)
-    if (this.types.isCallExpression(path.node) && this.types.isCallExpression(path.parentPath.node) && this.types.isExpression(path.node.arguments[0]) && path.parentPath.node.callee === path.node && this.isLinguiIdentifier(path.node.callee, "t")) {
-      const i18nInstance = path.node.arguments[0];
-      this.replaceTAsFunction(path.parentPath, i18nInstance);
-      return false;
-    }
-
-    // t({...})
-    if (this.types.isCallExpression(path.node) && this.isLinguiIdentifier(path.node.callee, "t")) {
-      this.replaceTAsFunction(path);
-      return true;
-    }
-    const tokens = this.tokenizeNode(path.node);
-    this.replacePathWithMessage(path, tokens);
-    return true;
-  };
-
-  /**
-   * macro `t` is called with MessageDescriptor, after that
-   * we create a new node to append it to i18n._
-   */
-  replaceTAsFunction = (path, linguiInstance) => {
-    const descriptor = this.processDescriptor(path.node.arguments[0]);
-    path.replaceWith(this.createI18nCall(descriptor, linguiInstance));
-  };
-
-  /**
-   * `processDescriptor` expand macros inside message descriptor.
-   * Message descriptor is used in `defineMessage`.
-   *
-   * {
-   *   comment: "Description",
-   *   message: plural("value", { one: "book", other: "books" })
-   * }
-   *
-   * ↓ ↓ ↓ ↓ ↓ ↓
-   *
-   * {
-   *   comment: "Description",
-   *   id: <hash>
-   *   message: "{value, plural, one {book} other {books}}"
-   * }
-   *
-   */
-  processDescriptor = descriptor_ => {
-    const descriptor = descriptor_;
-    const messageProperty = this.getObjectPropertyByKey(descriptor, _constants.MESSAGE);
-    const idProperty = this.getObjectPropertyByKey(descriptor, _constants.ID);
-    const contextProperty = this.getObjectPropertyByKey(descriptor, _constants.CONTEXT);
-    const properties = [idProperty];
-    if (!this.stripNonEssentialProps) {
-      properties.push(contextProperty);
-    }
-
-    // if there's `message` property, replace macros with formatted message
-    if (messageProperty) {
-      // Inside message descriptor the `t` macro in `message` prop is optional.
-      // Template strings are always processed as if they were wrapped by `t`.
-      const tokens = this.types.isTemplateLiteral(messageProperty.value) ? this.tokenizeTemplateLiteral(messageProperty.value) : this.tokenizeNode(messageProperty.value, true);
-      let messageNode = messageProperty.value;
-      if (tokens) {
-        const {
-          message,
-          values
-        } = buildICUFromTokens(tokens);
-        messageNode = this.types.stringLiteral(message);
-        properties.push(this.createValuesProperty(values));
-      }
-      if (!this.stripNonEssentialProps) {
-        properties.push(this.createObjectProperty(_constants.MESSAGE, messageNode));
-      }
-      if (!idProperty && this.types.isStringLiteral(messageNode)) {
-        const context = contextProperty && this.getTextFromExpression(contextProperty.value);
-        properties.push(this.createIdProperty(messageNode.value, context));
-      }
-    }
-    if (!this.stripNonEssentialProps) {
-      properties.push(this.getObjectPropertyByKey(descriptor, _constants.COMMENT));
-    }
-    return this.createMessageDescriptor(properties, descriptor.loc);
-  };
-  createIdProperty(message, context) {
-    return this.createObjectProperty(_constants.ID, this.types.stringLiteral((0, _api.generateMessageId)(message, context)));
-  }
-  createValuesProperty(values) {
-    const valuesObject = Object.keys(values).map(key => this.types.objectProperty(this.types.identifier(key), values[key]));
-    if (!valuesObject.length) return;
-    return this.types.objectProperty(this.types.identifier("values"), this.types.objectExpression(valuesObject));
-  }
-  tokenizeNode(node, ignoreExpression = false) {
-    if (this.isI18nMethod(node)) {
-      // t
-      return this.tokenizeTemplateLiteral(node);
-    } else if (this.isChoiceMethod(node)) {
-      // plural, select and selectOrdinal
-      return [this.tokenizeChoiceComponent(node)];
-      // } else if (isFormatMethod(node.callee)) {
-      //   // date, number
-      //   return transformFormatMethod(node, file, props, root)
-    } else if (!ignoreExpression) {
-      return [this.tokenizeExpression(node)];
-    }
-  }
-
-  /**
-   * `node` is a TemplateLiteral. node.quasi contains
-   * text chunks and node.expressions contains expressions.
-   * Both arrays must be zipped together to get the final list of tokens.
-   */
-  tokenizeTemplateLiteral(node) {
-    const tpl = this.types.isTaggedTemplateExpression(node) ? node.quasi : node;
-    const expressions = tpl.expressions;
-    return tpl.quasis.flatMap((text, i) => {
-      // 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;
-      let argTokens = [];
-      const currExp = expressions[i];
-      if (currExp) {
-        argTokens = this.types.isCallExpression(currExp) ? this.tokenizeNode(currExp) : [this.tokenizeExpression(currExp)];
-      }
-      return [...(value ? [{
-        type: "text",
-        value: this.clearBackslashes(value)
-      }] : []), ...argTokens];
-    });
-  }
-  tokenizeChoiceComponent(node) {
-    const name = node.callee.name;
-    const format = (this.nameMapReversed.get(name) || name).toLowerCase();
-    const token = {
-      ...this.tokenizeExpression(node.arguments[0]),
-      format,
-      options: {
-        offset: undefined
-      }
-    };
-    const props = node.arguments[1].properties;
-    for (const attr of props) {
-      const {
-        key,
-        value: attrValue
-      } = attr;
-
-      // name is either:
-      // NumericLiteral => convert to `={number}`
-      // StringLiteral => key.value
-      // Identifier => key.name
-      const name = this.types.isNumericLiteral(key) ? `=${key.value}` : key.name || key.value;
-      if (format !== "select" && name === "offset") {
-        token.options.offset = attrValue.value;
-      } else {
-        let value;
-        if (this.types.isTemplateLiteral(attrValue)) {
-          value = this.tokenizeTemplateLiteral(attrValue);
-        } else if (this.types.isCallExpression(attrValue)) {
-          value = this.tokenizeNode(attrValue);
-        } else if (this.types.isStringLiteral(attrValue)) {
-          value = attrValue.value;
-        } else if (this.types.isExpression(attrValue)) {
-          value = this.tokenizeExpression(attrValue);
-        } else {
-          value = attrValue.value;
-        }
-        token.options[name] = value;
-      }
-    }
-    return token;
-  }
-  tokenizeExpression(node) {
-    if (this.isArg(node) && this.types.isCallExpression(node)) {
-      return {
-        type: "arg",
-        name: node.arguments[0].value,
-        value: undefined
-      };
-    }
-    return {
-      type: "arg",
-      name: this.expressionToArgument(node),
-      value: node
-    };
-  }
-  expressionToArgument(exp) {
-    if (this.types.isIdentifier(exp)) {
-      return exp.name;
-    } else if (this.types.isStringLiteral(exp)) {
-      return exp.value;
-    } else {
-      return String(this._expressionIndex());
-    }
-  }
-
-  /**
-   * We clean '//\` ' to just '`'
-   */
-  clearBackslashes(value) {
-    // if not we replace the extra scaped literals
-    return value.replace(/\\`/g, "`");
-  }
-  createI18nCall(messageDescriptor, linguiInstance) {
-    return this.types.callExpression(this.types.memberExpression(linguiInstance ?? this.types.identifier(this.i18nImportName), this.types.identifier("_")), [messageDescriptor]);
-  }
-  createMessageDescriptorFromTokens(tokens, oldLoc) {
-    const {
-      message,
-      values
-    } = buildICUFromTokens(tokens);
-    const properties = [this.createIdProperty(message), !this.stripNonEssentialProps ? this.createObjectProperty(_constants.MESSAGE, this.types.stringLiteral(message)) : null, this.createValuesProperty(values)];
-    return this.createMessageDescriptor(properties,
-    // preserve line numbers for extractor
-    oldLoc);
-  }
-  createMessageDescriptor(properties, oldLoc) {
-    const newDescriptor = this.types.objectExpression(properties.filter(Boolean));
-    this.types.addComment(newDescriptor, "leading", _constants.EXTRACT_MARK);
-    if (oldLoc) {
-      newDescriptor.loc = oldLoc;
-    }
-    return newDescriptor;
-  }
-  createObjectProperty(key, value) {
-    return this.types.objectProperty(this.types.identifier(key), value);
-  }
-  getObjectPropertyByKey(objectExp, key) {
-    return objectExp.properties.find(property => (0, _types.isObjectProperty)(property) && this.isLinguiIdentifier(property.key, key));
-  }
-
-  /**
-   * Custom matchers
-   */
-  isLinguiIdentifier(node, name) {
-    return this.types.isIdentifier(node, {
-      name: this.nameMap.get(name) || name
-    });
-  }
-  isDefineMessage(node) {
-    return this.isLinguiIdentifier(node, "defineMessage") || this.isLinguiIdentifier(node, "msg");
-  }
-  isArg(node) {
-    return this.types.isCallExpression(node) && this.isLinguiIdentifier(node.callee, "arg");
-  }
-  isI18nMethod(node) {
-    return this.types.isTaggedTemplateExpression(node) && (this.isLinguiIdentifier(node.tag, "t") || this.types.isCallExpression(node.tag) && this.isLinguiIdentifier(node.tag.callee, "t"));
-  }
-  isChoiceMethod(node) {
-    return this.types.isCallExpression(node) && (this.isLinguiIdentifier(node.callee, "plural") || this.isLinguiIdentifier(node.callee, "select") || this.isLinguiIdentifier(node.callee, "selectOrdinal"));
-  }
-  getTextFromExpression(exp) {
-    if (this.types.isStringLiteral(exp)) {
-      return exp.value;
-    }
-    if (this.types.isTemplateLiteral(exp)) {
-      if ((exp === null || exp === void 0 ? void 0 : exp.quasis.length) === 1) {
-        var _exp$quasis$, _exp$quasis$$value;
-        return (_exp$quasis$ = exp.quasis[0]) === null || _exp$quasis$ === void 0 ? void 0 : (_exp$quasis$$value = _exp$quasis$.value) === null || _exp$quasis$$value === void 0 ? void 0 : _exp$quasis$$value.cooked;
-      }
-    }
-  }
-}
-exports.default = MacroJs;

package/build/macroJsx.js

@@ -1,313 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-exports.normalizeWhitespace = normalizeWhitespace;
-var _icu = _interopRequireDefault(require("./icu"));
-var _utils = require("./utils");
-var _constants = require("./constants");
-var _api = require("@lingui/cli/api");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-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, "}")
-  // we remove leading whitespace inside Plural
-  .replace(/({\s+)/gm, "{").trim();
-}
-class MacroJSX {
-  expressionIndex = (0, _utils.makeCounter)();
-  elementIndex = (0, _utils.makeCounter)();
-  constructor({
-    types
-  }, opts) {
-    this.types = types;
-    this.stripNonEssentialProps = opts.stripNonEssentialProps;
-    this.nameMap = opts.nameMap;
-    this.nameMapReversed = Array.from(opts.nameMap.entries()).reduce((map, [key, value]) => map.set(value, key), new Map());
-  }
-  createStringJsxAttribute = (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);
-    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);
-    if (!id && !message) {
-      return;
-    }
-    if (id) {
-      attributes.push(this.types.jsxAttribute(this.types.jsxIdentifier(_constants.ID), this.types.stringLiteral(id)));
-    } else {
-      attributes.push(this.createStringJsxAttribute(_constants.ID, (0, _api.generateMessageId)(message, context)));
-    }
-    if (!this.stripNonEssentialProps) {
-      if (message) {
-        attributes.push(this.createStringJsxAttribute(_constants.MESSAGE, message));
-      }
-      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, true), null, [], 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 = path => {
-    const {
-      attributes
-    } = path.node.openingElement;
-    const id = attributes.find(this.attrName([_constants.ID]));
-    const message = attributes.find(this.attrName([_constants.MESSAGE]));
-    const comment = attributes.find(this.attrName([_constants.COMMENT]));
-    const context = attributes.find(this.attrName([_constants.CONTEXT]));
-    let reserved = [_constants.ID, _constants.MESSAGE, _constants.COMMENT, _constants.CONTEXT];
-    if (this.isChoiceComponent(path)) {
-      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 = path => {
-    if (this.isTransComponent(path)) {
-      // t
-      return this.tokenizeTrans(path);
-    } else if (this.isChoiceComponent(path)) {
-      // plural, select and selectOrdinal
-      return [this.tokenizeChoiceComponent(path)];
-    } else if (path.isJSXElement()) {
-      return [this.tokenizeElement(path)];
-    } else {
-      return [this.tokenizeExpression(path)];
-    }
-  };
-  tokenizeTrans = path => {
-    return path.get("children").flatMap(child => this.tokenizeChildren(child)).filter(Boolean);
-  };
-  tokenizeChildren = path => {
-    if (path.isJSXExpressionContainer()) {
-      const exp = path.get("expression");
-      if (exp.isStringLiteral()) {
-        // Escape forced newlines to keep them in message.
-        return [this.tokenizeText(exp.node.value.replace(/\n/g, "\\n"))];
-      }
-      if (exp.isTemplateLiteral()) {
-        return this.tokenizeTemplateLiteral(exp);
-      }
-      if (exp.isConditionalExpression()) {
-        return [this.tokenizeConditionalExpression(exp)];
-      }
-      if (exp.isJSXElement()) {
-        return this.tokenizeNode(exp);
-      }
-      return [this.tokenizeExpression(exp)];
-    } else if (path.isJSXElement()) {
-      return this.tokenizeNode(path);
-    } else if (path.isJSXSpreadChild()) {
-      // just do nothing
-    } else if (path.isJSXText()) {
-      return [this.tokenizeText(path.node.value)];
-    } else {
-      // impossible path
-      // return this.tokenizeText(node.value)
-    }
-  };
-  tokenizeTemplateLiteral(exp) {
-    const expressions = exp.get("expressions");
-    return exp.get("quasis").flatMap(({
-      node: text
-    }, i) => {
-      // 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;
-      let argTokens = [];
-      const currExp = expressions[i];
-      if (currExp) {
-        argTokens = currExp.isCallExpression() ? this.tokenizeNode(currExp) : [this.tokenizeExpression(currExp)];
-      }
-      return [...(value ? [this.tokenizeText(this.clearBackslashes(value))] : []), ...argTokens];
-    });
-  }
-  tokenizeChoiceComponent = path => {
-    const element = path.get("openingElement");
-    const name = this.getJsxTagName(path.node);
-    const format = (this.nameMapReversed.get(name) || name).toLowerCase();
-    const props = element.get("attributes").filter(attr => {
-      return 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)(attr.node);
-    });
-    const token = {
-      type: "arg",
-      format,
-      name: null,
-      value: undefined,
-      options: {
-        offset: undefined
-      }
-    };
-    for (const _attr of props) {
-      if (_attr.isJSXSpreadAttribute()) {
-        continue;
-      }
-      const attr = _attr;
-      if (this.types.isJSXNamespacedName(attr.node.name)) {
-        continue;
-      }
-      const name = attr.node.name.name;
-      const value = attr.get("value");
-      if (name === "value") {
-        const exp = value.isLiteral() ? value : value.get("expression");
-        token.name = this.expressionToArgument(exp);
-        token.value = exp.node;
-      } else if (format !== "select" && name === "offset") {
-        // offset is static parameter, so it must be either string or number
-        token.options.offset = value.isStringLiteral() || value.isNumericLiteral() ? value.node.value : value.get("expression").node.value;
-      } else {
-        let option;
-        if (value.isStringLiteral()) {
-          option = value.node.extra.raw.replace(/(["'])(.*)\1/, "$2");
-        } else {
-          option = this.tokenizeChildren(value);
-        }
-        if (pluralRuleRe.test(name)) {
-          token.options[jsx2icuExactChoice(name)] = option;
-        } else {
-          token.options[name] = option;
-        }
-      }
-    }
-    return token;
-  };
-  tokenizeElement = path => {
-    // !!! Important: Calculate element index before traversing children.
-    // That way outside elements are numbered before inner elements. (...and it looks pretty).
-    const name = this.elementIndex();
-    return {
-      type: "element",
-      name,
-      value: {
-        ...path.node,
-        children: [],
-        openingElement: {
-          ...path.node.openingElement,
-          selfClosing: true
-        }
-      },
-      children: this.tokenizeTrans(path)
-    };
-  };
-  tokenizeExpression = path => {
-    return {
-      type: "arg",
-      name: this.expressionToArgument(path),
-      value: path.node
-    };
-  };
-  tokenizeConditionalExpression = exp => {
-    exp.traverse({
-      JSXElement: el => {
-        if (this.isTransComponent(el) || this.isChoiceComponent(el)) {
-          this.replacePath(el);
-          el.skip();
-        }
-      }
-    });
-    return {
-      type: "arg",
-      name: this.expressionToArgument(exp),
-      value: exp.node
-    };
-  };
-  tokenizeText = value => {
-    return {
-      type: "text",
-      value
-    };
-  };
-  expressionToArgument(path) {
-    return path.isIdentifier() ? path.node.name : String(this.expressionIndex());
-  }
-
-  /**
-   * We clean '//\` ' to just '`'
-   **/
-  clearBackslashes(value) {
-    // if not we replace the extra scaped literals
-    return value.replace(/\\`/g, "`");
-  }
-  isLinguiComponent = (path, name) => {
-    return path.isJSXElement() && this.types.isJSXIdentifier(path.node.openingElement.name, {
-      name: this.nameMap.get(name) || name
-    });
-  };
-  isTransComponent = path => {
-    return this.isLinguiComponent(path, "Trans");
-  };
-  isChoiceComponent = path => {
-    return this.isLinguiComponent(path, "Plural") || this.isLinguiComponent(path, "Select") || this.isLinguiComponent(path, "SelectOrdinal");
-  };
-  getJsxTagName = node => {
-    if (this.types.isJSXIdentifier(node.openingElement.name)) {
-      return node.openingElement.name.name;
-    }
-  };
-}
-exports.default = MacroJSX;

package/build/utils.js

@@ -1,8 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.makeCounter = void 0;
-const makeCounter = (index = 0) => () => index++;
-exports.makeCounter = makeCounter;