babel-plugin-formatjs 10.3.26 → 10.3.27

package/index.d.ts

@@ -0,0 +1,10 @@
+import { PluginObj, PluginPass } from '@babel/core';
+import { ExtractedMessageDescriptor, Options } from './types';
+export declare type ExtractionResult<M = Record<string, string>> = {
+    messages: ExtractedMessageDescriptor[];
+    meta: M;
+};
+export declare const DEFAULT_ID_INTERPOLATION_PATTERN = "[sha512:contenthash:base64:6]";
+declare const _default: (api: object, options: Options | null | undefined, dirname: string) => PluginObj<PluginPass>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,SAAS,EAAE,UAAU,EAAC,MAAM,aAAa,CAAA;AAEjD,OAAO,EAAC,0BAA0B,EAAE,OAAO,EAAQ,MAAM,SAAS,CAAA;AAIlE,oBAAY,gBAAgB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAAI;IACzD,QAAQ,EAAE,0BAA0B,EAAE,CAAA;IACtC,IAAI,EAAE,CAAC,CAAA;CACR,CAAA;AAED,eAAO,MAAM,gCAAgC,kCAAkC,CAAA;;AAG/E,wBAwEE"}

package/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ID_INTERPOLATION_PATTERN = void 0;
+const tslib_1 = require("tslib");
+const helper_plugin_utils_1 = require("@babel/helper-plugin-utils");
+const plugin_syntax_jsx_1 = tslib_1.__importDefault(require("@babel/plugin-syntax-jsx"));
+const jsx_opening_element_1 = require("./visitors/jsx-opening-element");
+const call_expression_1 = require("./visitors/call-expression");
+exports.DEFAULT_ID_INTERPOLATION_PATTERN = '[sha512:contenthash:base64:6]';
+// @ts-expect-error PluginPass doesn't allow custom state but it actually does
+exports.default = (0, helper_plugin_utils_1.declare)((api, options) => {
+    api.assertVersion(7);
+    if (!options.idInterpolationPattern) {
+        options.idInterpolationPattern = exports.DEFAULT_ID_INTERPOLATION_PATTERN;
+    }
+    const { pragma } = options;
+    const componentNames = new Set(options.additionalComponentNames);
+    componentNames.add('FormattedMessage');
+    const functionNames = new Set(options.additionalFunctionNames);
+    functionNames.add('formatMessage');
+    // Vue
+    functionNames.add('$formatMessage');
+    return {
+        inherits: plugin_syntax_jsx_1.default,
+        pre() {
+            this.componentNames = Array.from(componentNames);
+            this.functionNames = Array.from(functionNames);
+        },
+        visitor: {
+            Program: {
+                enter(path) {
+                    this.messages = [];
+                    this.meta = {};
+                    if (!pragma) {
+                        return;
+                    }
+                    for (const { leadingComments } of path.node.body) {
+                        if (!leadingComments) {
+                            continue;
+                        }
+                        const pragmaLineNode = leadingComments.find(c => c.value.includes(pragma));
+                        if (!pragmaLineNode) {
+                            continue;
+                        }
+                        pragmaLineNode.value
+                            .split(pragma)[1]
+                            .trim()
+                            .split(/\s+/g)
+                            .forEach(kv => {
+                            const [k, v] = kv.split(':');
+                            this.meta[k] = v;
+                        });
+                    }
+                },
+                exit(_, { opts: _opts, file: { opts: { filename }, }, }) {
+                    const opts = _opts;
+                    if (typeof opts?.onMetaExtracted === 'function') {
+                        opts.onMetaExtracted(filename || '', this.meta);
+                    }
+                    if (typeof opts?.onMsgExtracted === 'function') {
+                        opts.onMsgExtracted(filename || '', this.messages);
+                    }
+                },
+            },
+            JSXOpeningElement: jsx_opening_element_1.visitor,
+            CallExpression: call_expression_1.visitor,
+        },
+    };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babel-plugin-formatjs",
-  "version": "10.3.26",
+  "version": "10.3.27",
   "description": "Extracts string messages for translation from modules that use formatjs.",
   "repository": {
     "type": "git",
@@ -16,8 +16,8 @@
     "@babel/plugin-syntax-jsx": "7",
     "@babel/traverse": "7",
     "@babel/types": "^7.12.11",
-    "@formatjs/icu-messageformat-parser": "2.1.5",
-    "@formatjs/ts-transformer": "3.9.10",
+    "@formatjs/icu-messageformat-parser": "2.1.6",
+    "@formatjs/ts-transformer": "3.9.11",
     "@types/babel__core": "^7.1.7",
     "@types/babel__helper-plugin-utils": "^7.10.0",
     "@types/babel__traverse": "^7.1.7",

package/types.d.ts

@@ -0,0 +1,31 @@
+import { NodePath } from '@babel/core';
+import { JSXExpressionContainer, SourceLocation, StringLiteral } from '@babel/types';
+export interface MessageDescriptor {
+    id: string;
+    defaultMessage?: string;
+    description?: string;
+}
+export interface State {
+    messages: ExtractedMessageDescriptor[];
+    meta: Record<string, string>;
+    componentNames: string[];
+    functionNames: string[];
+}
+export declare type ExtractedMessageDescriptor = MessageDescriptor & Partial<SourceLocation> & {
+    file?: string;
+};
+export declare type MessageDescriptorPath = Record<keyof MessageDescriptor, NodePath<StringLiteral> | NodePath<JSXExpressionContainer> | undefined>;
+export interface Options {
+    overrideIdFn?: (id?: string, defaultMessage?: string, description?: string, filePath?: string) => string;
+    onMsgExtracted?: (filePath: string, msgs: MessageDescriptor[]) => void;
+    onMetaExtracted?: (filePath: string, meta: Record<string, string>) => void;
+    idInterpolationPattern?: string;
+    removeDefaultMessage?: boolean;
+    additionalComponentNames?: string[];
+    additionalFunctionNames?: string[];
+    pragma?: string;
+    extractSourceLocation?: boolean;
+    ast?: boolean;
+    preserveWhitespace?: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAA;AACpC,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,aAAa,EACd,MAAM,cAAc,CAAA;AAErB,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,EAAE,0BAA0B,EAAE,CAAA;IACtC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC5B,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,aAAa,EAAE,MAAM,EAAE,CAAA;CACxB;AAED,oBAAY,0BAA0B,GAAG,iBAAiB,GACxD,OAAO,CAAC,cAAc,CAAC,GAAG;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,CAAA;AAE3C,oBAAY,qBAAqB,GAAG,MAAM,CACxC,MAAM,iBAAiB,EACvB,QAAQ,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,sBAAsB,CAAC,GAAG,SAAS,CACvE,CAAA;AAED,MAAM,WAAW,OAAO;IACtB,YAAY,CAAC,EAAE,CACb,EAAE,CAAC,EAAE,MAAM,EACX,cAAc,CAAC,EAAE,MAAM,EACvB,WAAW,CAAC,EAAE,MAAM,EACpB,QAAQ,CAAC,EAAE,MAAM,KACd,MAAM,CAAA;IACX,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,KAAK,IAAI,CAAA;IACtE,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAA;IAC1E,sBAAsB,CAAC,EAAE,MAAM,CAAA;IAC/B,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;IACnC,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAA;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B"}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils.d.ts

@@ -0,0 +1,34 @@
+import * as t from '@babel/types';
+import { Options, ExtractedMessageDescriptor, MessageDescriptor, MessageDescriptorPath } from './types';
+import { NodePath } from '@babel/core';
+export declare function getMessageDescriptorKey(path: NodePath<any>): string;
+export declare function createMessageDescriptor(propPaths: [
+    NodePath<t.JSXIdentifier> | NodePath<t.Identifier>,
+    NodePath<t.StringLiteral> | NodePath<t.JSXExpressionContainer>
+][]): MessageDescriptorPath;
+export declare function evaluateMessageDescriptor(descriptorPath: MessageDescriptorPath, isJSXSource: boolean | undefined, filename: string | undefined, idInterpolationPattern?: string, overrideIdFn?: Options['overrideIdFn'], preserveWhitespace?: Options['preserveWhitespace']): MessageDescriptor;
+/**
+ * Tag a node as extracted
+ * Store this in the node itself so that multiple passes work. Specifically
+ * if we remove `description` in the 1st pass, 2nd pass will fail since
+ * it expect `description` to be there.
+ * HACK: We store this in the node instance since this persists across
+ * multiple plugin runs
+ * @param path
+ */
+export declare function tagAsExtracted(path: NodePath<any>): void;
+/**
+ * Check if a node was extracted
+ * @param path
+ */
+export declare function wasExtracted(path: NodePath<any>): boolean;
+/**
+ * Store a message in our global messages
+ * @param messageDescriptor
+ * @param path
+ * @param opts
+ * @param filename
+ * @param messages
+ */
+export declare function storeMessage({ id, description, defaultMessage }: MessageDescriptor, path: NodePath<any>, { extractSourceLocation }: Options, filename: string | undefined, messages: ExtractedMessageDescriptor[]): void;
+//# sourceMappingURL=utils.d.ts.map

package/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AAIjC,OAAO,EACL,OAAO,EACP,0BAA0B,EAC1B,iBAAiB,EACjB,qBAAqB,EACtB,MAAM,SAAS,CAAA;AAChB,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAA;AAmBpC,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,UAM1D;AA0BD,wBAAgB,uBAAuB,CACrC,SAAS,EAAE;IACT,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC;IAClD,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,sBAAsB,CAAC;CAC/D,EAAE,GACF,qBAAqB,CAmBvB;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,qBAAqB,EACrC,WAAW,qBAAQ,EACnB,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,sBAAsB,CAAC,EAAE,MAAM,EAC/B,YAAY,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,EACtC,kBAAkB,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,qBAqCnD;AA6CD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,QAEjD;AACD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,WAE/C;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,EAAC,EAAE,EAAE,WAAW,EAAE,cAAc,EAAC,EAAE,iBAAiB,EACpD,IAAI,EAAE,QAAQ,CAAC,GAAG,CAAC,EACnB,EAAC,qBAAqB,EAAC,EAAE,OAAO,EAEhC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,QAAQ,EAAE,0BAA0B,EAAE,QAgBvC"}

package/utils.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeMessage = exports.wasExtracted = exports.tagAsExtracted = exports.evaluateMessageDescriptor = exports.createMessageDescriptor = exports.getMessageDescriptorKey = void 0;
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const ts_transformer_1 = require("@formatjs/ts-transformer");
+const DESCRIPTOR_PROPS = new Set([
+    'id',
+    'description',
+    'defaultMessage',
+]);
+function evaluatePath(path) {
+    const evaluated = path.evaluate();
+    if (evaluated.confident) {
+        return evaluated.value;
+    }
+    throw path.buildCodeFrameError('[React Intl] Messages must be statically evaluate-able for extraction.');
+}
+function getMessageDescriptorKey(path) {
+    if (path.isIdentifier() || path.isJSXIdentifier()) {
+        return path.node.name;
+    }
+    return evaluatePath(path);
+}
+exports.getMessageDescriptorKey = getMessageDescriptorKey;
+function getMessageDescriptorValue(path, isMessageNode) {
+    if (!path) {
+        return '';
+    }
+    if (path.isJSXExpressionContainer()) {
+        // If this is already compiled, no need to recompiled it
+        if (isMessageNode && path.get('expression').isArrayExpression()) {
+            return '';
+        }
+        path = path.get('expression');
+    }
+    // Always trim the Message Descriptor values.
+    const descriptorValue = evaluatePath(path);
+    return descriptorValue;
+}
+function createMessageDescriptor(propPaths) {
+    return propPaths.reduce((hash, [keyPath, valuePath]) => {
+        const key = getMessageDescriptorKey(keyPath);
+        if (DESCRIPTOR_PROPS.has(key)) {
+            hash[key] = valuePath;
+        }
+        return hash;
+    }, {
+        id: undefined,
+        defaultMessage: undefined,
+        description: undefined,
+    });
+}
+exports.createMessageDescriptor = createMessageDescriptor;
+function evaluateMessageDescriptor(descriptorPath, isJSXSource = false, filename, idInterpolationPattern, overrideIdFn, preserveWhitespace) {
+    let id = getMessageDescriptorValue(descriptorPath.id);
+    const defaultMessage = getICUMessageValue(descriptorPath.defaultMessage, {
+        isJSXSource,
+    }, preserveWhitespace);
+    const description = getMessageDescriptorValue(descriptorPath.description);
+    if (overrideIdFn) {
+        id = overrideIdFn(id, defaultMessage, description, filename);
+    }
+    else if (!id && idInterpolationPattern && defaultMessage) {
+        id = (0, ts_transformer_1.interpolateName)({ resourcePath: filename }, idInterpolationPattern, {
+            content: description
+                ? `${defaultMessage}#${description}`
+                : defaultMessage,
+        });
+    }
+    const descriptor = {
+        id,
+    };
+    if (description) {
+        descriptor.description = description;
+    }
+    if (defaultMessage) {
+        descriptor.defaultMessage = defaultMessage;
+    }
+    return descriptor;
+}
+exports.evaluateMessageDescriptor = evaluateMessageDescriptor;
+function getICUMessageValue(messagePath, { isJSXSource = false } = {}, preserveWhitespace) {
+    if (!messagePath) {
+        return '';
+    }
+    let message = getMessageDescriptorValue(messagePath, true);
+    if (!preserveWhitespace) {
+        message = message.trim().replace(/\s+/gm, ' ');
+    }
+    try {
+        (0, icu_messageformat_parser_1.parse)(message);
+    }
+    catch (parseError) {
+        if (isJSXSource &&
+            messagePath.isLiteral() &&
+            message.indexOf('\\\\') >= 0) {
+            throw messagePath.buildCodeFrameError('[React Intl] Message failed to parse. ' +
+                'It looks like `\\`s were used for escaping, ' +
+                "this won't work with JSX string literals. " +
+                'Wrap with `{}`. ' +
+                'See: http://facebook.github.io/react/docs/jsx-gotchas.html');
+        }
+        throw messagePath.buildCodeFrameError('[React Intl] Message failed to parse. ' +
+            'See: https://formatjs.io/docs/core-concepts/icu-syntax' +
+            `\n${parseError}`);
+    }
+    return message;
+}
+const EXTRACTED = Symbol('FormatJSExtracted');
+/**
+ * Tag a node as extracted
+ * Store this in the node itself so that multiple passes work. Specifically
+ * if we remove `description` in the 1st pass, 2nd pass will fail since
+ * it expect `description` to be there.
+ * HACK: We store this in the node instance since this persists across
+ * multiple plugin runs
+ * @param path
+ */
+function tagAsExtracted(path) {
+    path.node[EXTRACTED] = true;
+}
+exports.tagAsExtracted = tagAsExtracted;
+/**
+ * Check if a node was extracted
+ * @param path
+ */
+function wasExtracted(path) {
+    return !!path.node[EXTRACTED];
+}
+exports.wasExtracted = wasExtracted;
+/**
+ * Store a message in our global messages
+ * @param messageDescriptor
+ * @param path
+ * @param opts
+ * @param filename
+ * @param messages
+ */
+function storeMessage({ id, description, defaultMessage }, path, { extractSourceLocation }, filename, messages) {
+    if (!id && !defaultMessage) {
+        throw path.buildCodeFrameError('[React Intl] Message Descriptors require an `id` or `defaultMessage`.');
+    }
+    let loc = {};
+    if (extractSourceLocation) {
+        loc = {
+            file: filename,
+            ...path.node.loc,
+        };
+    }
+    messages.push({ id, description, defaultMessage, ...loc });
+}
+exports.storeMessage = storeMessage;

package/visitors/call-expression.d.ts

@@ -0,0 +1,6 @@
+import { PluginPass } from '@babel/core';
+import * as t from '@babel/types';
+import { State } from '../types';
+import { VisitNodeFunction } from '@babel/traverse';
+export declare const visitor: VisitNodeFunction<PluginPass & State, t.CallExpression>;
+//# sourceMappingURL=call-expression.d.ts.map

package/visitors/call-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"call-expression.d.ts","sourceRoot":"","sources":["call-expression.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,UAAU,EAAC,MAAM,aAAa,CAAA;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AACjC,OAAO,EAAU,KAAK,EAAC,MAAM,UAAU,CAAA;AACvC,OAAO,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAA;AAoDjD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CAAC,UAAU,GAAG,KAAK,EAAE,CAAC,CAAC,cAAc,CAwJzE,CAAA"}

package/visitors/call-expression.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitor = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("@babel/types"));
+const utils_1 = require("../utils");
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+function assertObjectExpression(path, callee) {
+    if (!path || !path.isObjectExpression()) {
+        throw path.buildCodeFrameError(`[React Intl] \`${callee.get('property').node.name}()\` must be called with an object expression with values that are React Intl Message Descriptors, also defined as object expressions.`);
+    }
+}
+function isFormatMessageCall(callee, functionNames) {
+    if (functionNames.find(name => callee.isIdentifier({ name }))) {
+        return true;
+    }
+    if (callee.isMemberExpression()) {
+        const property = callee.get('property');
+        return !!functionNames.find(name => property.isIdentifier({ name }));
+    }
+    return false;
+}
+function getMessagesObjectFromExpression(nodePath) {
+    let currentPath = nodePath;
+    while (t.isTSAsExpression(currentPath.node) ||
+        t.isTSTypeAssertion(currentPath.node) ||
+        t.isTypeCastExpression(currentPath.node)) {
+        currentPath = currentPath.get('expression');
+    }
+    return currentPath;
+}
+const visitor = function (path, { opts, file: { opts: { filename }, }, }) {
+    const { overrideIdFn, idInterpolationPattern, removeDefaultMessage, ast, preserveWhitespace, } = opts;
+    if ((0, utils_1.wasExtracted)(path)) {
+        return;
+    }
+    const { messages, functionNames } = this;
+    const callee = path.get('callee');
+    const args = path.get('arguments');
+    /**
+     * Process MessageDescriptor
+     * @param messageDescriptor Message Descriptor
+     */
+    function processMessageObject(messageDescriptor) {
+        assertObjectExpression(messageDescriptor, callee);
+        const properties = messageDescriptor.get('properties');
+        const descriptorPath = (0, utils_1.createMessageDescriptor)(properties.map(prop => [prop.get('key'), prop.get('value')]));
+        // If the message is already compiled, don't re-compile it
+        if (descriptorPath.defaultMessage?.isArrayExpression()) {
+            return;
+        }
+        // Evaluate the Message Descriptor values, then store it.
+        const descriptor = (0, utils_1.evaluateMessageDescriptor)(descriptorPath, false, filename || undefined, idInterpolationPattern, overrideIdFn, preserveWhitespace);
+        (0, utils_1.storeMessage)(descriptor, messageDescriptor, opts, filename || undefined, messages);
+        const firstProp = properties[0];
+        const defaultMessageProp = properties.find(prop => {
+            const keyProp = prop.get('key');
+            return (keyProp.isIdentifier({ name: 'defaultMessage' }) ||
+                keyProp.isStringLiteral({ value: 'defaultMessage' }));
+        });
+        const idProp = properties.find(prop => {
+            const keyProp = prop.get('key');
+            return (keyProp.isIdentifier({ name: 'id' }) ||
+                keyProp.isStringLiteral({ value: 'id' }));
+        });
+        // Insert ID potentially 1st before removing nodes
+        if (idProp) {
+            idProp.get('value').replaceWith(t.stringLiteral(descriptor.id));
+        }
+        else {
+            firstProp.insertBefore(t.objectProperty(t.identifier('id'), t.stringLiteral(descriptor.id)));
+        }
+        // Remove description
+        properties
+            .find(prop => {
+            const keyProp = prop.get('key');
+            return (keyProp.isIdentifier({ name: 'description' }) ||
+                keyProp.isStringLiteral({ value: 'description' }));
+        })
+            ?.remove();
+        // Pre-parse or remove defaultMessage
+        if (defaultMessageProp) {
+            if (removeDefaultMessage) {
+                defaultMessageProp?.remove();
+            }
+            else if (descriptor.defaultMessage) {
+                const valueProp = defaultMessageProp.get('value');
+                if (ast) {
+                    valueProp.replaceWithSourceString(JSON.stringify((0, icu_messageformat_parser_1.parse)(descriptor.defaultMessage)));
+                }
+                else {
+                    valueProp.replaceWith(t.stringLiteral(descriptor.defaultMessage));
+                }
+            }
+        }
+        (0, utils_1.tagAsExtracted)(path);
+    }
+    // Check that this is `defineMessages` call
+    if (callee.isIdentifier({ name: 'defineMessages' }) ||
+        callee.isIdentifier({ name: 'defineMessage' })) {
+        const firstArgument = args[0];
+        const messagesObj = getMessagesObjectFromExpression(firstArgument);
+        assertObjectExpression(messagesObj, callee);
+        if (callee.isIdentifier({ name: 'defineMessage' })) {
+            processMessageObject(messagesObj);
+        }
+        else {
+            const properties = messagesObj.get('properties');
+            if (Array.isArray(properties)) {
+                properties
+                    .map(prop => prop.get('value'))
+                    .forEach(processMessageObject);
+            }
+        }
+    }
+    // Check that this is `intl.formatMessage` call
+    if (isFormatMessageCall(callee, functionNames)) {
+        const messageDescriptor = args[0];
+        if (messageDescriptor.isObjectExpression()) {
+            processMessageObject(messageDescriptor);
+        }
+    }
+};
+exports.visitor = visitor;

package/visitors/jsx-opening-element.d.ts

@@ -0,0 +1,6 @@
+import { PluginPass } from '@babel/core';
+import { State } from '../types';
+import * as t from '@babel/types';
+import { VisitNodeFunction } from '@babel/traverse';
+export declare const visitor: VisitNodeFunction<PluginPass & State, t.JSXOpeningElement>;
+//# sourceMappingURL=jsx-opening-element.d.ts.map

package/visitors/jsx-opening-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-opening-element.d.ts","sourceRoot":"","sources":["jsx-opening-element.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,UAAU,EAAC,MAAM,aAAa,CAAA;AAEhD,OAAO,EAAU,KAAK,EAAC,MAAM,UAAU,CAAA;AACvC,OAAO,KAAK,CAAC,MAAM,cAAc,CAAA;AACjC,OAAO,EAAC,iBAAiB,EAAC,MAAM,iBAAiB,CAAA;AAWjD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC,UAAU,GAAG,KAAK,EAClB,CAAC,CAAC,iBAAiB,CAiIpB,CAAA"}

package/visitors/jsx-opening-element.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitor = void 0;
+const tslib_1 = require("tslib");
+const t = tslib_1.__importStar(require("@babel/types"));
+const icu_messageformat_parser_1 = require("@formatjs/icu-messageformat-parser");
+const utils_1 = require("../utils");
+const visitor = function (path, { opts, file: { opts: { filename }, }, }) {
+    const { removeDefaultMessage, idInterpolationPattern, overrideIdFn, ast, preserveWhitespace, } = opts;
+    const { componentNames, messages } = this;
+    if ((0, utils_1.wasExtracted)(path)) {
+        return;
+    }
+    const name = path.get('name');
+    if (!componentNames.find(n => name.isJSXIdentifier({ name: n }))) {
+        return;
+    }
+    const attributes = path
+        .get('attributes')
+        .filter(attr => attr.isJSXAttribute());
+    const descriptorPath = (0, utils_1.createMessageDescriptor)(attributes.map(attr => [
+        attr.get('name'),
+        attr.get('value'),
+    ]));
+    // In order for a default message to be extracted when
+    // declaring a JSX element, it must be done with standard
+    // `key=value` attributes. But it's completely valid to
+    // write `<FormattedMessage {...descriptor} />`, because it will be
+    // skipped here and extracted elsewhere. The descriptor will
+    // be extracted only (storeMessage) if a `defaultMessage` prop.
+    if (!descriptorPath.defaultMessage) {
+        return;
+    }
+    // Evaluate the Message Descriptor values in a JSX
+    // context, then store it.
+    const descriptor = (0, utils_1.evaluateMessageDescriptor)(descriptorPath, true, filename || undefined, idInterpolationPattern, overrideIdFn, preserveWhitespace);
+    (0, utils_1.storeMessage)(descriptor, path, opts, filename || undefined, messages);
+    let idAttr;
+    let descriptionAttr;
+    let defaultMessageAttr;
+    const firstAttr = attributes[0];
+    for (const attr of attributes) {
+        if (!attr.isJSXAttribute()) {
+            continue;
+        }
+        switch ((0, utils_1.getMessageDescriptorKey)(attr.get('name'))) {
+            case 'description':
+                descriptionAttr = attr;
+                break;
+            case 'defaultMessage':
+                defaultMessageAttr = attr;
+                break;
+            case 'id':
+                idAttr = attr;
+                break;
+        }
+    }
+    // Insert ID before removing node to prevent null node insertBefore
+    if (overrideIdFn || (descriptor.id && idInterpolationPattern)) {
+        if (idAttr) {
+            idAttr.get('value').replaceWith(t.stringLiteral(descriptor.id));
+        }
+        else if (firstAttr) {
+            firstAttr.insertBefore(t.jsxAttribute(t.jsxIdentifier('id'), t.stringLiteral(descriptor.id)));
+        }
+    }
+    if (descriptionAttr) {
+        descriptionAttr.remove();
+    }
+    if (defaultMessageAttr) {
+        if (removeDefaultMessage) {
+            defaultMessageAttr.remove();
+        }
+        else if (ast && descriptor.defaultMessage) {
+            defaultMessageAttr
+                .get('value')
+                .replaceWith(t.jsxExpressionContainer(t.nullLiteral()));
+            const valueAttr = defaultMessageAttr.get('value');
+            valueAttr
+                .get('expression')
+                .replaceWithSourceString(JSON.stringify((0, icu_messageformat_parser_1.parse)(descriptor.defaultMessage)));
+        }
+    }
+    // Tag the AST node so we don't try to extract it twice.
+    (0, utils_1.tagAsExtracted)(path);
+};
+exports.visitor = visitor;

package/BUILD

@@ -1,90 +0,0 @@
-load("@aspect_bazel_lib//lib:write_source_files.bzl", "write_source_files")
-load("@aspect_rules_js//npm/private:npm_package.bzl", "npm_package")
-load("@npm//:defs.bzl", "npm_link_all_packages")
-load("//tools:index.bzl", "check_format", "package_json_test", "ts_compile_node")
-load("//tools:jest.bzl", "jest_test")
-
-npm_link_all_packages(name = "node_modules")
-
-PACKAGE_NAME = "babel-plugin-formatjs"
-
-npm_package(
-    name = PACKAGE_NAME,
-    srcs = [
-        "LICENSE.md",
-        "README.md",
-        "package.json",
-        ":dist",
-    ],
-    package = PACKAGE_NAME,
-    visibility = ["//visibility:public"],
-)
-
-SRCS = glob(
-    ["**/*.ts"],
-    exclude = ["tests/**/*"],
-)
-
-SRC_DEPS = [
-    "//:node_modules/@babel/core",
-    "//:node_modules/@babel/helper-plugin-utils",
-    "//:node_modules/@babel/plugin-syntax-jsx",
-    "//:node_modules/@babel/traverse",
-    "//:node_modules/@babel/types",
-    ":node_modules/@formatjs/icu-messageformat-parser",
-    ":node_modules/@formatjs/ts-transformer",
-    "//:node_modules/@types/babel__core",
-    "//:node_modules/@types/babel__helper-plugin-utils",
-    "//:node_modules/@types/babel__traverse",
-]
-
-ts_compile_node(
-    name = "dist",
-    srcs = SRCS,
-    deps = SRC_DEPS,
-)
-
-jest_test(
-    name = "unit",
-    srcs = SRCS + glob(
-        [
-            "tests/**/*.ts",
-            "tests/**/*.tsx",
-            "tests/**/*.js",
-            "tests/**/*.json",
-        ],
-        exclude = ["tests/vue/**/*"],
-    ),
-    snapshots = glob([
-        "tests/**/*.snap",
-    ]),
-    deps = [
-        "//:node_modules/@babel/preset-env",
-        "//:node_modules/@babel/preset-react",
-        "//:node_modules/@types/node",
-    ] + SRC_DEPS,
-)
-
-package_json_test(
-    name = "package_json_test",
-    deps = SRC_DEPS,
-)
-
-write_source_files(
-    name = "tsconfig_json",
-    files = {"tsconfig.json": "//tools:tsconfig.golden.json"},
-)
-
-check_format(
-    name = "prettier",
-    srcs = glob(
-        [
-            "**/*",
-        ],
-        exclude = [
-            "CHANGELOG.md",
-            "options.ts",
-            "tests/__snapshots__/*",
-        ],
-    ),
-)