@mui/internal-babel-plugin-minify-errors 2.0.8-canary.7 → 2.0.8-canary.8

package/index.js

@@ -1,26 +1,14 @@
-/**
- * @mui/internal-babel-plugin-minify-errors v2.0.8-canary.7
- *
- * @license MIT
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-"use strict";
+// @ts-check
+
+const helperModuleImports = require('@babel/helper-module-imports');
+const fs = require('fs');
+const nodePath = require('path');
+const finder = require('find-package-json');
 
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports["default"] = plugin;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var helperModuleImports = _interopRequireWildcard(require("@babel/helper-module-imports"));
-var fs = _interopRequireWildcard(require("node:fs"));
-var nodePath = _interopRequireWildcard(require("node:path"));
-var _findPackageJson = _interopRequireDefault(require("find-package-json"));
 /**
  * Normalize a file path to POSIX in order for it to be platform-agnostic.
+ * @param {string} importPath
+ * @returns {string}
  */
 function toPosixPath(importPath) {
   return nodePath.normalize(importPath).split(nodePath.sep).join(nodePath.posix.sep);
@@ -28,45 +16,63 @@ function toPosixPath(importPath) {
 
 /**
  * Converts a file path to a node import specifier.
+ * @param {string} importPath
+ * @returns {string}
  */
 function pathToNodeImportSpecifier(importPath) {
-  var normalized = toPosixPath(importPath);
-  return normalized.startsWith('/') || normalized.startsWith('.') ? normalized : "./".concat(normalized);
+  const normalized = toPosixPath(importPath);
+  return normalized.startsWith('/') || normalized.startsWith('.') ? normalized : `./${normalized}`;
 }
-var COMMENT_OPT_IN_MARKER = 'minify-error';
-var COMMENT_OPT_OUT_MARKER = 'minify-error-disabled';
+
+const COMMENT_OPT_IN_MARKER = 'minify-error';
+const COMMENT_OPT_OUT_MARKER = 'minify-error-disabled';
+
+/**
+ * @typedef {import('@babel/core')} babel
+ */
+
+/**
+ * @typedef {babel.PluginPass & {updatedErrorCodes?: boolean, formatErrorMessageIdentifier?: babel.types.Identifier}} PluginState
+ * @typedef {'annotate' | 'throw' | 'write'} MissingError
+ * @typedef {{
+ *   errorCodesPath: string,
+ *   missingError: MissingError,
+ *   runtimeModule?: string,
+ *   detection?: 'opt-in' | 'opt-out',
+ *   outExtension?: string
+ * }} Options
+ */
+
 /**
  * Extracts the message and expressions from a node.
+ * @param {babel.types} t
+ * @param {babel.types.Node} node
+ * @returns {{ message: string, expressions: babel.types.Expression[] } | null}
  */
 function extractMessage(t, node) {
   if (t.isTemplateLiteral(node)) {
     return {
-      message: node.quasis.map(function (quasi) {
-        return quasi.value.cooked;
-      }).join('%s'),
-      expressions: node.expressions.map(function (expression) {
+      message: node.quasis.map((quasi) => quasi.value.cooked).join('%s'),
+      expressions: node.expressions.map((expression) => {
         if (t.isExpression(expression)) {
           return expression;
         }
         throw new Error('Can only evaluate javascript template literals.');
-      })
+      }),
     };
   }
   if (t.isStringLiteral(node)) {
-    return {
-      message: node.value,
-      expressions: []
-    };
+    return { message: node.value, expressions: [] };
   }
   if (t.isBinaryExpression(node) && node.operator === '+') {
-    var left = extractMessage(t, node.left);
-    var right = extractMessage(t, node.right);
+    const left = extractMessage(t, node.left);
+    const right = extractMessage(t, node.right);
     if (!left || !right) {
       return null;
     }
     return {
       message: left.message + right.message,
-      expressions: [].concat((0, _toConsumableArray2["default"])(left.expressions), (0, _toConsumableArray2["default"])(right.expressions))
+      expressions: [...left.expressions, ...right.expressions],
     };
   }
   return null;
@@ -74,189 +80,259 @@ function extractMessage(t, node) {
 
 /**
  * Handles unminifyable errors based on the missingError option.
+ * @param {MissingError} missingError
+ * @param {babel.NodePath} path
  */
 function handleUnminifyableError(missingError, path) {
   switch (missingError) {
     case 'annotate':
-      path.addComment('leading', ' FIXME (minify-errors-in-prod): Unminifyable error in production! ');
+      path.addComment(
+        'leading',
+        ' FIXME (minify-errors-in-prod): Unminifyable error in production! ',
+      );
       break;
     case 'throw':
-      throw new Error('Unminifyable error. You can only use literal strings and template strings as error messages.');
+      throw new Error(
+        'Unminifyable error. You can only use literal strings and template strings as error messages.',
+      );
     case 'write':
       break;
     default:
-      throw new Error("Unknown missingError option: ".concat(missingError));
+      throw new Error(`Unknown missingError option: ${missingError}`);
   }
 }
 
 /**
  * Transforms the error message node.
+ * @param {babel.types} t
+ * @param {babel.NodePath} path
+ * @param {babel.types.Expression} messageNode
+ * @param {PluginState} state
+ * @param {Map<string, number>} errorCodesLookup
+ * @param {MissingError} missingError
+ * @param {string} runtimeModule
+ * @param {string} outExtension
+ * @returns {babel.types.Expression | null}
  */
-function transformMessage(t, path, messageNode, state, errorCodesLookup, missingError, runtimeModule, outExtension) {
-  var message = extractMessage(t, messageNode);
+function transformMessage(
+  t,
+  path,
+  messageNode,
+  state,
+  errorCodesLookup,
+  missingError,
+  runtimeModule,
+  outExtension,
+) {
+  const message = extractMessage(t, messageNode);
   if (!message) {
     handleUnminifyableError(missingError, path);
     return null;
   }
-  var errorCode = errorCodesLookup.get(message.message);
+
+  let errorCode = errorCodesLookup.get(message.message);
   if (errorCode === undefined) {
     switch (missingError) {
       case 'annotate':
-        path.addComment('leading', ' FIXME (minify-errors-in-prod): Unminified error message in production build! ');
+        path.addComment(
+          'leading',
+          ' FIXME (minify-errors-in-prod): Unminified error message in production build! ',
+        );
         return null;
       case 'throw':
-        throw new Error("Missing error code for message '".concat(message.message, "'. Did you forget to run `pnpm extract-error-codes` first?"));
+        throw new Error(
+          `Missing error code for message '${message.message}'. Did you forget to run \`pnpm extract-error-codes\` first?`,
+        );
       case 'write':
         errorCode = errorCodesLookup.size + 1;
         errorCodesLookup.set(message.message, errorCode);
         state.updatedErrorCodes = true;
         break;
       default:
-        throw new Error("Unknown missingError option: ".concat(missingError));
+        throw new Error(`Unknown missingError option: ${missingError}`);
     }
   }
+
   if (!state.formatErrorMessageIdentifier) {
-    state.formatErrorMessageIdentifier = helperModuleImports.addDefault(path, transformExtension(resolveRuntimeModule(runtimeModule, state), outExtension), {
-      nameHint: '_formatErrorMessage'
-    });
+    state.formatErrorMessageIdentifier = helperModuleImports.addDefault(
+      path,
+      transformExtension(resolveRuntimeModule(runtimeModule, state), outExtension),
+      { nameHint: '_formatErrorMessage' },
+    );
   }
-  return t.conditionalExpression(t.binaryExpression('!==', t.memberExpression(t.memberExpression(t.identifier('process'), t.identifier('env')), t.identifier('NODE_ENV')), t.stringLiteral('production')), messageNode, t.callExpression(t.cloneNode(state.formatErrorMessageIdentifier, true), [t.numericLiteral(errorCode)].concat((0, _toConsumableArray2["default"])(message.expressions))));
+
+  return t.conditionalExpression(
+    t.binaryExpression(
+      '!==',
+      t.memberExpression(
+        t.memberExpression(t.identifier('process'), t.identifier('env')),
+        t.identifier('NODE_ENV'),
+      ),
+      t.stringLiteral('production'),
+    ),
+    messageNode,
+    t.callExpression(t.cloneNode(state.formatErrorMessageIdentifier, true), [
+      t.numericLiteral(errorCode),
+      ...message.expressions,
+    ]),
+  );
 }
 
 /**
  * Resolves the runtime module path recursively.
+ * @param {string} runtimeModule
+ * @param {PluginState} state
+ * @param {Set<string>} [visitedModules]
+ * @returns {string}
  */
-function resolveRuntimeModule(runtimeModule, state) {
-  var _pkg$imports;
-  var visitedModules = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
+function resolveRuntimeModule(runtimeModule, state, visitedModules = new Set()) {
   if (!runtimeModule.startsWith('#')) {
     return runtimeModule;
   }
-  var currentFile = state.filename;
+
+  const currentFile = state.filename;
   if (!currentFile) {
     throw new Error('filename is not defined');
   }
-  var result = (0, _findPackageJson["default"])(currentFile).next();
+
+  const result = finder(currentFile).next();
   if (result.done) {
     throw new Error('Could not find package.json');
   }
-  var pkg = result.value;
-  var pkgPath = result.filename;
-  var runtimeModulePath = pkg == null || (_pkg$imports = pkg.imports) == null ? void 0 : _pkg$imports[runtimeModule];
+
+  const pkg = result.value;
+  const pkgPath = result.filename;
+  const runtimeModulePath = pkg?.imports?.[runtimeModule];
   if (typeof runtimeModulePath !== 'string') {
-    throw new Error("Invalid runtime module path for ".concat(runtimeModule));
+    throw new Error(`Invalid runtime module path for ${runtimeModule}`);
   }
+
   if (visitedModules.has(runtimeModule)) {
-    throw new Error("Circular import detected for ".concat(runtimeModule));
+    throw new Error(`Circular import detected for ${runtimeModule}`);
   }
   visitedModules.add(runtimeModule);
+
   if (runtimeModulePath.startsWith('.')) {
-    var resolvedPath = nodePath.resolve(nodePath.dirname(pkgPath), runtimeModulePath);
-    var relativePath = nodePath.relative(nodePath.dirname(currentFile), resolvedPath);
+    const resolvedPath = nodePath.resolve(nodePath.dirname(pkgPath), runtimeModulePath);
+    const relativePath = nodePath.relative(nodePath.dirname(currentFile), resolvedPath);
     return pathToNodeImportSpecifier(relativePath);
   }
+
   return resolveRuntimeModule(runtimeModulePath, state, visitedModules);
 }
 
 /**
- * Transform file extension of import specifier.
+ *
+ * @param {string} importSpecifier
+ * @param {string} outExtension
+ * @returns
  */
-function transformExtension(importSpecifier) {
-  var outExtension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.js';
+function transformExtension(importSpecifier, outExtension = '.js') {
   return importSpecifier.replace(/\.[a-zA-Z0-9]+$/, outExtension);
 }
 
 /**
- * Babel plugin for minifying error messages.
+ * @param {babel} file
+ * @param {Options} options
+ * @returns {babel.PluginObj<PluginState>}
  */
-function plugin(_ref, _ref2) {
-  var t = _ref.types;
-  var errorCodesPath = _ref2.errorCodesPath,
-    _ref2$missingError = _ref2.missingError,
-    missingError = _ref2$missingError === void 0 ? 'annotate' : _ref2$missingError,
-    _ref2$runtimeModule = _ref2.runtimeModule,
-    runtimeModule = _ref2$runtimeModule === void 0 ? '#formatErrorMessage' : _ref2$runtimeModule,
-    _ref2$detection = _ref2.detection,
-    detection = _ref2$detection === void 0 ? 'opt-in' : _ref2$detection,
-    _ref2$outExtension = _ref2.outExtension,
-    outExtension = _ref2$outExtension === void 0 ? '.js' : _ref2$outExtension;
+module.exports = function plugin(
+  { types: t },
+  {
+    errorCodesPath,
+    missingError = 'annotate',
+    runtimeModule = '#formatErrorMessage',
+    detection = 'opt-in',
+    outExtension = '.js',
+  },
+) {
   if (!errorCodesPath) {
     throw new Error('errorCodesPath is required.');
   }
-  var errorCodesContent = fs.readFileSync(errorCodesPath, 'utf8');
-  var errorCodes = JSON.parse(errorCodesContent);
-  var errorCodesLookup = new Map(Object.entries(errorCodes).map(function (_ref3) {
-    var _ref4 = (0, _slicedToArray2["default"])(_ref3, 2),
-      key = _ref4[0],
-      value = _ref4[1];
-    return [value, Number(key)];
-  }));
+
+  const errorCodesContent = fs.readFileSync(errorCodesPath, 'utf8');
+  const errorCodes = JSON.parse(errorCodesContent);
+
+  const errorCodesLookup = new Map(
+    Object.entries(errorCodes).map(([key, value]) => [value, Number(key)]),
+  );
+
   return {
     name: '@mui/internal-babel-plugin-minify-errors',
     visitor: {
-      NewExpression: function NewExpression(newExpressionPath, state) {
-        if (!newExpressionPath.get('callee').isIdentifier({
-          name: 'Error'
-        })) {
+      NewExpression(newExpressionPath, state) {
+        if (!newExpressionPath.get('callee').isIdentifier({ name: 'Error' })) {
           return;
         }
+
         switch (detection) {
-          case 'opt-in':
-            {
-              var _newExpressionPath$no;
-              if (!((_newExpressionPath$no = newExpressionPath.node.leadingComments) != null && _newExpressionPath$no.some(function (comment) {
-                return comment.value.includes(COMMENT_OPT_IN_MARKER);
-              }))) {
-                return;
-              }
-              newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(function (comment) {
-                return !comment.value.includes(COMMENT_OPT_IN_MARKER);
-              });
-              break;
+          case 'opt-in': {
+            if (
+              !newExpressionPath.node.leadingComments?.some((comment) =>
+                comment.value.includes(COMMENT_OPT_IN_MARKER),
+              )
+            ) {
+              return;
             }
-          case 'opt-out':
-            {
-              var _newExpressionPath$no2;
-              if ((_newExpressionPath$no2 = newExpressionPath.node.leadingComments) != null && _newExpressionPath$no2.some(function (comment) {
-                return comment.value.includes(COMMENT_OPT_OUT_MARKER);
-              })) {
-                newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(function (comment) {
-                  return !comment.value.includes(COMMENT_OPT_OUT_MARKER);
-                });
-                return;
-              }
-              break;
-            }
-          default:
-            {
-              throw new Error("Unknown detection option: ".concat(detection));
+            newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(
+              (comment) => !comment.value.includes(COMMENT_OPT_IN_MARKER),
+            );
+            break;
+          }
+          case 'opt-out': {
+            if (
+              newExpressionPath.node.leadingComments?.some((comment) =>
+                comment.value.includes(COMMENT_OPT_OUT_MARKER),
+              )
+            ) {
+              newExpressionPath.node.leadingComments =
+                newExpressionPath.node.leadingComments.filter(
+                  (comment) => !comment.value.includes(COMMENT_OPT_OUT_MARKER),
+                );
+              return;
             }
+
+            break;
+          }
+          default: {
+            throw new Error(`Unknown detection option: ${detection}`);
+          }
         }
-        var messagePath = newExpressionPath.get('arguments')[0];
+
+        const messagePath = newExpressionPath.get('arguments')[0];
         if (!messagePath) {
           return;
         }
-        var messageNode = messagePath.node;
+
+        const messageNode = messagePath.node;
         if (t.isSpreadElement(messageNode) || t.isArgumentPlaceholder(messageNode)) {
           handleUnminifyableError(missingError, newExpressionPath);
           return;
         }
-        var transformedMessage = transformMessage(t, newExpressionPath, messageNode, state, errorCodesLookup, missingError, runtimeModule, outExtension);
+
+        const transformedMessage = transformMessage(
+          t,
+          newExpressionPath,
+          messageNode,
+          state,
+          errorCodesLookup,
+          missingError,
+          runtimeModule,
+          outExtension,
+        );
+
         if (transformedMessage) {
           messagePath.replaceWith(transformedMessage);
         }
-      }
+      },
     },
-    post: function post() {
+    post() {
       if (missingError === 'write' && this.updatedErrorCodes) {
-        var invertedErrorCodes = Object.fromEntries(Array.from(errorCodesLookup, function (_ref5) {
-          var _ref6 = (0, _slicedToArray2["default"])(_ref5, 2),
-            key = _ref6[0],
-            value = _ref6[1];
-          return [value, key];
-        }));
-        fs.writeFileSync(errorCodesPath, "".concat(JSON.stringify(invertedErrorCodes, null, 2), "\n"));
+        const invertedErrorCodes = Object.fromEntries(
+          Array.from(errorCodesLookup, ([key, value]) => [value, key]),
+        );
+        fs.writeFileSync(errorCodesPath, `${JSON.stringify(invertedErrorCodes, null, 2)}\n`);
       }
-    }
+    },
   };
-}
+};

package/index.test.js

@@ -0,0 +1,170 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { pluginTester } from 'babel-plugin-tester';
+import { expect } from 'vitest';
+import plugin from './index';
+
+const temporaryErrorCodesPath = path.join(os.tmpdir(), 'error-codes.json');
+const fixturePath = path.resolve(__dirname, './__fixtures__');
+
+/**
+ *
+ * @param {string} fixture
+ * @param {string} file
+ * @returns {string}
+ */
+function readOutputFixtureSync(fixture, file) {
+  // babel hardcodes the linefeed to \n
+  return fs
+    .readFileSync(path.join(fixturePath, fixture, file), { encoding: 'utf8' })
+    .replace(/\r?\n/g, '\n');
+}
+
+pluginTester({
+  plugin,
+  pluginName: 'minify-errors',
+  filepath: __filename,
+  tests: [
+    {
+      title: 'literal',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'literal', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      fixture: path.join(fixturePath, 'literal', 'input.js'),
+      output: readOutputFixtureSync('literal', 'output.js'),
+    },
+    {
+      title: 'interpolation',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'interpolation', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      fixture: path.join(fixturePath, 'interpolation', 'input.js'),
+      output: readOutputFixtureSync('interpolation', 'output.js'),
+    },
+    {
+      title: 'annotates missing error codes',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'no-error-code-annotation', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      fixture: path.join(fixturePath, 'no-error-code-annotation', 'input.js'),
+      output: readOutputFixtureSync('no-error-code-annotation', 'output.js'),
+    },
+    {
+      title: 'can throw on missing error codes',
+      // babel prefixes with filename.
+      // We're only interested in the message.
+      error:
+        /: Missing error code for message 'missing'. Did you forget to run `pnpm extract-error-codes` first\?/,
+      fixture: path.join(fixturePath, 'no-error-code-throw', 'input.js'),
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'no-error-code-throw', 'error-codes.json'),
+        missingError: 'throw',
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+    },
+    {
+      title: 'annotates unminifyable errors',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'unminifyable-annotation', 'error-codes.json'),
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      fixture: path.join(fixturePath, 'unminifyable-annotation', 'input.js'),
+      output: readOutputFixtureSync('unminifyable-annotation', 'output.js'),
+    },
+    {
+      title: 'can throw on unminifyable errors',
+      // babel prefixes with filename.
+      // We're only interested in the message.
+      error:
+        /: Unminifyable error. You can only use literal strings and template strings as error messages./,
+      fixture: path.join(fixturePath, 'unminifyable-throw', 'input.js'),
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'unminifyable-throw', 'error-codes.json'),
+        missingError: 'throw',
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+    },
+    {
+      title: 'can extract errors',
+      fixture: path.join(fixturePath, 'error-code-extraction', 'input.js'),
+      pluginOptions: {
+        errorCodesPath: temporaryErrorCodesPath,
+        missingError: 'write',
+        runtimeModule: '@mui/utils/formatMuiErrorMessage',
+      },
+      output: readOutputFixtureSync('error-code-extraction', 'output.js'),
+      setup() {
+        fs.copyFileSync(
+          path.join(fixturePath, 'error-code-extraction', 'error-codes.before.json'),
+          temporaryErrorCodesPath,
+        );
+
+        return function teardown() {
+          try {
+            const actualErrorCodes = JSON.parse(
+              fs.readFileSync(temporaryErrorCodesPath, { encoding: 'utf8' }),
+            );
+            const expectedErrorCodes = JSON.parse(
+              fs.readFileSync(
+                path.join(fixturePath, 'error-code-extraction', 'error-codes.after.json'),
+                'utf-8',
+              ),
+            );
+
+            expect(actualErrorCodes).to.deep.equal(expectedErrorCodes);
+          } finally {
+            fs.unlinkSync(temporaryErrorCodesPath);
+          }
+        };
+      },
+    },
+    {
+      title: 'uses custom runtime module',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'custom-runtime', 'error-codes.json'),
+        runtimeModule: '@custom/error-formatter',
+      },
+      fixture: path.join(fixturePath, 'custom-runtime', 'input.js'),
+      output: readOutputFixtureSync('custom-runtime', 'output.js'),
+    },
+    {
+      title: 'uses custom runtime module with imports',
+      pluginOptions: {
+        errorCodesPath: path.join(fixturePath, 'custom-runtime-imports', 'error-codes.json'),
+        runtimeModule: '#error-formatter',
+      },
+      fixture: path.join(fixturePath, 'custom-runtime-imports', 'input.js'),
+      output: readOutputFixtureSync('custom-runtime-imports', 'output.js'),
+    },
+    {
+      title: 'uses custom runtime module with relative path',
+      pluginOptions: {
+        errorCodesPath: path.join(
+          fixturePath,
+          'custom-runtime-imports-relative',
+          'error-codes.json',
+        ),
+        runtimeModule: '#error-formatter',
+      },
+      fixture: path.join(fixturePath, 'custom-runtime-imports-relative', 'input.js'),
+      output: readOutputFixtureSync('custom-runtime-imports-relative', 'output.js'),
+    },
+    {
+      title: 'uses custom runtime module with recursive imports',
+      pluginOptions: {
+        errorCodesPath: path.join(
+          fixturePath,
+          'custom-runtime-imports-recursive',
+          'error-codes.json',
+        ),
+        runtimeModule: '#error-formatter',
+      },
+      fixture: path.join(fixturePath, 'custom-runtime-imports-recursive', 'input.js'),
+      output: readOutputFixtureSync('custom-runtime-imports-recursive', 'output.js'),
+    },
+  ],
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-babel-plugin-minify-errors",
-  "version": "2.0.8-canary.7",
+  "version": "2.0.8-canary.8",
   "author": "MUI Team",
   "description": "This is an internal package not meant for general use.",
   "repository": {
@@ -20,32 +20,28 @@
     "@babel/helper-module-imports": "^7.27.1",
     "find-package-json": "^1.2.0"
   },
+  "devDependencies": {
+    "@babel/core": "^7.28.3",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__helper-module-imports": "^7.18.3",
+    "@types/find-package-json": "^1.2.6",
+    "babel-plugin-tester": "^12.0.0"
+  },
   "peerDependencies": {
     "@babel/core": "7"
   },
   "sideEffects": false,
   "type": "commonjs",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
   "engines": {
     "node": ">=14.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitSha": "ad561386f8eaa51a46c7ce0c17df6ad1ba929d3d",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": {
-      "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": {
-        "types": "./index.d.ts",
-        "default": "./index.js"
-      }
-    },
-    "./esm": null
-  }
+  "gitSha": "6a3e097acfa56e9838d2edb7f05755bda41f365d",
+  "scripts": {}
 }

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "allowJs": true,
+    "checkJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "outDir": "./build",
+    "noEmit": true,
+    "composite": true
+  },
+  "include": ["."],
+  "exclude": ["node_modules", "build", "__fixtures__"]
+}

package/vite.config.mts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    // babel-plugin-tester expects it
+    globals: true,
+  },
+});

package/CHANGELOG.md

@@ -1,5 +0,0 @@
-# Versions
-
-## 2.0.6
-
-Changelog start

package/README.md

@@ -1,38 +0,0 @@
-# MUI Public
-
-Mono-repository for the MUI organization with code that can be public.
-See https://github.com/mui/mui-private for code that needs to be private.
-
-## Applications
-
-### [tools-public.mui.com](https://tools-public.mui.com/)
-
-- Folder: `/apps/tools-public/`
-- Hosting: https://dashboard.render.com/web/srv-d08mooq4d50c73fso49g
-- [Docs](./apps/tools-public/#readme)
-
-Internal public Toolpad apps that run the operations of MUI, built using https://github.com/mui/toolpad.
-
-### [frontend-public.mui.com](https://frontend-public.mui.com/)
-
-- Folder: `/apps/code-infra-dashboard/`
-- Hosting: https://app.netlify.com/sites/mui-frontend-public/overview
-- [Docs](./apps/code-infra-dashboard/#readme)
-
-## Versioning
-
-Steps:
-
-1. Checkout latest master
-1. Run `pnpm release:prepare`
-1. Run `pnpm release:version`
-1. Open PR with the changes
-
-## Publishing
-
-Steps:
-
-1. Merge versioning PR
-1. Checkout release commit on master
-1. Run `pnpm release:prepare`
-1. Run `pnpm release:publish`

package/esm/index.d.ts

@@ -1,25 +0,0 @@
-import * as babel from '@babel/core';
-export interface PluginState extends babel.PluginPass {
-  updatedErrorCodes?: boolean;
-  formatErrorMessageIdentifier?: babel.types.Identifier;
-}
-export type MissingError = 'annotate' | 'throw' | 'write';
-export interface Options {
-  errorCodesPath: string;
-  missingError?: MissingError;
-  runtimeModule?: string;
-  detection?: 'opt-in' | 'opt-out';
-  outExtension?: string;
-}
-/**
- * Babel plugin for minifying error messages.
- */
-export default function plugin({
-  types: t
-}: typeof babel, {
-  errorCodesPath,
-  missingError,
-  runtimeModule,
-  detection,
-  outExtension
-}: Options): babel.PluginObj<PluginState>;

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../home/runner/work/mui-public/mui-public/packages/babel-plugin-minify-errors/src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAuBrC,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,UAAU;IACnD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,4BAA4B,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;CACvD;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAE1D,MAAM,WAAW,OAAO;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAkLD;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,EAC1B,EACE,cAAc,EACd,YAAyB,EACzB,aAAqC,EACrC,SAAoB,EACpB,YAAoB,GACrB,EAAE,OAAO,GACT,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CA6F9B"}

package/esm/index.js

@@ -1,255 +0,0 @@
-/**
- * @mui/internal-babel-plugin-minify-errors v2.0.8-canary.7
- *
- * @license MIT
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import * as helperModuleImports from '@babel/helper-module-imports';
-import * as fs from 'node:fs';
-import * as nodePath from 'node:path';
-import finder from 'find-package-json';
-
-/**
- * Normalize a file path to POSIX in order for it to be platform-agnostic.
- */
-function toPosixPath(importPath) {
-  return nodePath.normalize(importPath).split(nodePath.sep).join(nodePath.posix.sep);
-}
-
-/**
- * Converts a file path to a node import specifier.
- */
-function pathToNodeImportSpecifier(importPath) {
-  var normalized = toPosixPath(importPath);
-  return normalized.startsWith('/') || normalized.startsWith('.') ? normalized : "./".concat(normalized);
-}
-var COMMENT_OPT_IN_MARKER = 'minify-error';
-var COMMENT_OPT_OUT_MARKER = 'minify-error-disabled';
-/**
- * Extracts the message and expressions from a node.
- */
-function extractMessage(t, node) {
-  if (t.isTemplateLiteral(node)) {
-    return {
-      message: node.quasis.map(function (quasi) {
-        return quasi.value.cooked;
-      }).join('%s'),
-      expressions: node.expressions.map(function (expression) {
-        if (t.isExpression(expression)) {
-          return expression;
-        }
-        throw new Error('Can only evaluate javascript template literals.');
-      })
-    };
-  }
-  if (t.isStringLiteral(node)) {
-    return {
-      message: node.value,
-      expressions: []
-    };
-  }
-  if (t.isBinaryExpression(node) && node.operator === '+') {
-    var left = extractMessage(t, node.left);
-    var right = extractMessage(t, node.right);
-    if (!left || !right) {
-      return null;
-    }
-    return {
-      message: left.message + right.message,
-      expressions: [].concat(_toConsumableArray(left.expressions), _toConsumableArray(right.expressions))
-    };
-  }
-  return null;
-}
-
-/**
- * Handles unminifyable errors based on the missingError option.
- */
-function handleUnminifyableError(missingError, path) {
-  switch (missingError) {
-    case 'annotate':
-      path.addComment('leading', ' FIXME (minify-errors-in-prod): Unminifyable error in production! ');
-      break;
-    case 'throw':
-      throw new Error('Unminifyable error. You can only use literal strings and template strings as error messages.');
-    case 'write':
-      break;
-    default:
-      throw new Error("Unknown missingError option: ".concat(missingError));
-  }
-}
-
-/**
- * Transforms the error message node.
- */
-function transformMessage(t, path, messageNode, state, errorCodesLookup, missingError, runtimeModule, outExtension) {
-  var message = extractMessage(t, messageNode);
-  if (!message) {
-    handleUnminifyableError(missingError, path);
-    return null;
-  }
-  var errorCode = errorCodesLookup.get(message.message);
-  if (errorCode === undefined) {
-    switch (missingError) {
-      case 'annotate':
-        path.addComment('leading', ' FIXME (minify-errors-in-prod): Unminified error message in production build! ');
-        return null;
-      case 'throw':
-        throw new Error("Missing error code for message '".concat(message.message, "'. Did you forget to run `pnpm extract-error-codes` first?"));
-      case 'write':
-        errorCode = errorCodesLookup.size + 1;
-        errorCodesLookup.set(message.message, errorCode);
-        state.updatedErrorCodes = true;
-        break;
-      default:
-        throw new Error("Unknown missingError option: ".concat(missingError));
-    }
-  }
-  if (!state.formatErrorMessageIdentifier) {
-    state.formatErrorMessageIdentifier = helperModuleImports.addDefault(path, transformExtension(resolveRuntimeModule(runtimeModule, state), outExtension), {
-      nameHint: '_formatErrorMessage'
-    });
-  }
-  return t.conditionalExpression(t.binaryExpression('!==', t.memberExpression(t.memberExpression(t.identifier('process'), t.identifier('env')), t.identifier('NODE_ENV')), t.stringLiteral('production')), messageNode, t.callExpression(t.cloneNode(state.formatErrorMessageIdentifier, true), [t.numericLiteral(errorCode)].concat(_toConsumableArray(message.expressions))));
-}
-
-/**
- * Resolves the runtime module path recursively.
- */
-function resolveRuntimeModule(runtimeModule, state) {
-  var _pkg$imports;
-  var visitedModules = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Set();
-  if (!runtimeModule.startsWith('#')) {
-    return runtimeModule;
-  }
-  var currentFile = state.filename;
-  if (!currentFile) {
-    throw new Error('filename is not defined');
-  }
-  var result = finder(currentFile).next();
-  if (result.done) {
-    throw new Error('Could not find package.json');
-  }
-  var pkg = result.value;
-  var pkgPath = result.filename;
-  var runtimeModulePath = pkg == null || (_pkg$imports = pkg.imports) == null ? void 0 : _pkg$imports[runtimeModule];
-  if (typeof runtimeModulePath !== 'string') {
-    throw new Error("Invalid runtime module path for ".concat(runtimeModule));
-  }
-  if (visitedModules.has(runtimeModule)) {
-    throw new Error("Circular import detected for ".concat(runtimeModule));
-  }
-  visitedModules.add(runtimeModule);
-  if (runtimeModulePath.startsWith('.')) {
-    var resolvedPath = nodePath.resolve(nodePath.dirname(pkgPath), runtimeModulePath);
-    var relativePath = nodePath.relative(nodePath.dirname(currentFile), resolvedPath);
-    return pathToNodeImportSpecifier(relativePath);
-  }
-  return resolveRuntimeModule(runtimeModulePath, state, visitedModules);
-}
-
-/**
- * Transform file extension of import specifier.
- */
-function transformExtension(importSpecifier) {
-  var outExtension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '.js';
-  return importSpecifier.replace(/\.[a-zA-Z0-9]+$/, outExtension);
-}
-
-/**
- * Babel plugin for minifying error messages.
- */
-export default function plugin(_ref, _ref2) {
-  var t = _ref.types;
-  var errorCodesPath = _ref2.errorCodesPath,
-    _ref2$missingError = _ref2.missingError,
-    missingError = _ref2$missingError === void 0 ? 'annotate' : _ref2$missingError,
-    _ref2$runtimeModule = _ref2.runtimeModule,
-    runtimeModule = _ref2$runtimeModule === void 0 ? '#formatErrorMessage' : _ref2$runtimeModule,
-    _ref2$detection = _ref2.detection,
-    detection = _ref2$detection === void 0 ? 'opt-in' : _ref2$detection,
-    _ref2$outExtension = _ref2.outExtension,
-    outExtension = _ref2$outExtension === void 0 ? '.js' : _ref2$outExtension;
-  if (!errorCodesPath) {
-    throw new Error('errorCodesPath is required.');
-  }
-  var errorCodesContent = fs.readFileSync(errorCodesPath, 'utf8');
-  var errorCodes = JSON.parse(errorCodesContent);
-  var errorCodesLookup = new Map(Object.entries(errorCodes).map(function (_ref3) {
-    var _ref4 = _slicedToArray(_ref3, 2),
-      key = _ref4[0],
-      value = _ref4[1];
-    return [value, Number(key)];
-  }));
-  return {
-    name: '@mui/internal-babel-plugin-minify-errors',
-    visitor: {
-      NewExpression: function NewExpression(newExpressionPath, state) {
-        if (!newExpressionPath.get('callee').isIdentifier({
-          name: 'Error'
-        })) {
-          return;
-        }
-        switch (detection) {
-          case 'opt-in':
-            {
-              var _newExpressionPath$no;
-              if (!((_newExpressionPath$no = newExpressionPath.node.leadingComments) != null && _newExpressionPath$no.some(function (comment) {
-                return comment.value.includes(COMMENT_OPT_IN_MARKER);
-              }))) {
-                return;
-              }
-              newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(function (comment) {
-                return !comment.value.includes(COMMENT_OPT_IN_MARKER);
-              });
-              break;
-            }
-          case 'opt-out':
-            {
-              var _newExpressionPath$no2;
-              if ((_newExpressionPath$no2 = newExpressionPath.node.leadingComments) != null && _newExpressionPath$no2.some(function (comment) {
-                return comment.value.includes(COMMENT_OPT_OUT_MARKER);
-              })) {
-                newExpressionPath.node.leadingComments = newExpressionPath.node.leadingComments.filter(function (comment) {
-                  return !comment.value.includes(COMMENT_OPT_OUT_MARKER);
-                });
-                return;
-              }
-              break;
-            }
-          default:
-            {
-              throw new Error("Unknown detection option: ".concat(detection));
-            }
-        }
-        var messagePath = newExpressionPath.get('arguments')[0];
-        if (!messagePath) {
-          return;
-        }
-        var messageNode = messagePath.node;
-        if (t.isSpreadElement(messageNode) || t.isArgumentPlaceholder(messageNode)) {
-          handleUnminifyableError(missingError, newExpressionPath);
-          return;
-        }
-        var transformedMessage = transformMessage(t, newExpressionPath, messageNode, state, errorCodesLookup, missingError, runtimeModule, outExtension);
-        if (transformedMessage) {
-          messagePath.replaceWith(transformedMessage);
-        }
-      }
-    },
-    post: function post() {
-      if (missingError === 'write' && this.updatedErrorCodes) {
-        var invertedErrorCodes = Object.fromEntries(Array.from(errorCodesLookup, function (_ref5) {
-          var _ref6 = _slicedToArray(_ref5, 2),
-            key = _ref6[0],
-            value = _ref6[1];
-          return [value, key];
-        }));
-        fs.writeFileSync(errorCodesPath, "".concat(JSON.stringify(invertedErrorCodes, null, 2), "\n"));
-      }
-    }
-  };
-}

package/esm/package.json

@@ -1 +0,0 @@
-{"type":"module","sideEffects":false}

package/index.d.ts

@@ -1,25 +0,0 @@
-import * as babel from '@babel/core';
-export interface PluginState extends babel.PluginPass {
-  updatedErrorCodes?: boolean;
-  formatErrorMessageIdentifier?: babel.types.Identifier;
-}
-export type MissingError = 'annotate' | 'throw' | 'write';
-export interface Options {
-  errorCodesPath: string;
-  missingError?: MissingError;
-  runtimeModule?: string;
-  detection?: 'opt-in' | 'opt-out';
-  outExtension?: string;
-}
-/**
- * Babel plugin for minifying error messages.
- */
-export default function plugin({
-  types: t
-}: typeof babel, {
-  errorCodesPath,
-  missingError,
-  runtimeModule,
-  detection,
-  outExtension
-}: Options): babel.PluginObj<PluginState>;

package/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../home/runner/work/mui-public/mui-public/packages/babel-plugin-minify-errors/src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAuBrC,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,UAAU;IACnD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,4BAA4B,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;CACvD;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC;AAE1D,MAAM,WAAW,OAAO;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAkLD;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAC5B,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,EAC1B,EACE,cAAc,EACd,YAAyB,EACzB,aAAqC,EACrC,SAAoB,EACpB,YAAoB,GACrB,EAAE,OAAO,GACT,KAAK,CAAC,SAAS,CAAC,WAAW,CAAC,CA6F9B"}