vite-plugin-enter-dev 0.0.12 → 0.0.14

package/dist/configure.js

@@ -31,12 +31,15 @@ function configureVite(source) {
     if (!types.isIdentifier(config.callee) || !defineNames.includes(config.callee.name) || config.arguments.length !== 1) throw new Error("Unsupported Vite config wrapper");
     config = config.arguments[0];
   }
+  let setup = [];
   if (types.isArrowFunctionExpression(config) || types.isFunctionExpression(config)) {
     if (types.isBlockStatement(config.body)) {
-      if (config.body.body.length !== 1 || !types.isReturnStatement(config.body.body[0])) {
+      const last = config.body.body.at(-1);
+      if (!types.isReturnStatement(last)) {
         throw new Error("Unsupported Vite config: expected a single unconditional return");
       }
-      config = config.body.body[0].argument ?? void 0;
+      setup = config.body.body.slice(0, -1);
+      config = last.argument ?? void 0;
     } else {
       config = config.body;
     }
@@ -54,14 +57,16 @@ function configureVite(source) {
     config.properties.push(plugins);
     changed = true;
   }
-  if (!types.isObjectProperty(plugins) || !types.isArrayExpression(plugins.value)) {
-    throw new Error("Unsupported Vite config: expected a literal plugins array");
-  }
-  const calls = plugins.value.elements.map((node) => types.isSpreadElement(node) ? node.argument : node);
+  if (!types.isObjectProperty(plugins)) throw new Error("Unsupported plugins property");
+  const pluginArrays = resolvePluginArrays(plugins.value, setup);
+  const calls = pluginArrays.flatMap((group) => group.array.elements).map((node) => types.isSpreadElement(node) ? node.argument : node);
   if (calls.some((node) => !types.isCallExpression(node) && node !== null && !types.isBooleanLiteral(node))) {
     throw new Error("Unsupported Vite config: dynamic plugin list");
   }
-  const hostReact = calls.some((node) => types.isCallExpression(node) && types.isIdentifier(node.callee) && reactNames.includes(node.callee.name));
+  const reactGroups = pluginArrays.filter((group) => group.array.elements.some((element) => {
+    const node = types.isSpreadElement(element) ? element.argument : element;
+    return types.isCallExpression(node) && types.isIdentifier(node.callee) && reactNames.includes(node.callee.name);
+  }));
   for (const name of ["enterProdPlugin", "enterDevPlugin"]) {
     const specifiers = imports.filter((node) => node.source.value === "vite-plugin-enter-dev").flatMap((node) => node.specifiers).filter((node) => types.isImportSpecifier(node) && types.isIdentifier(node.imported, { name }));
     const aliases = specifiers.map((node) => node.local.name);
@@ -77,10 +82,16 @@ function configureVite(source) {
     let call = matching[0];
     if (!call) {
       call = types.callExpression(types.identifier(local), []);
-      plugins.value.elements.push(types.spreadElement(call));
+      pluginArrays[0].array.elements.push(types.spreadElement(call));
       changed = true;
     }
-    if (name !== "enterDevPlugin" || !hostReact || !types.isCallExpression(call)) continue;
+    if (name !== "enterDevPlugin" || !types.isCallExpression(call)) continue;
+    const devGroup = pluginArrays.find((group) => group.array.elements.some((element) => (types.isSpreadElement(element) ? element.argument : element) === call));
+    const hosts = reactGroups.filter((group) => !group.conditions.some((condition) => devGroup.conditions.some((other) => other.node === condition.node && other.branch !== condition.branch)));
+    if (!hosts.length) continue;
+    if (!hosts.some((group) => group.conditions.every((condition) => devGroup.conditions.some((other) => other.node === condition.node && other.branch === condition.branch)))) {
+      throw new Error("Unsupported conditional React compiler ownership");
+    }
     if (call.arguments.length === 0) call.arguments.push(types.objectExpression([]));
     const options = call.arguments[0];
     if (!types.isObjectExpression(options) || options.properties.some((node) => !types.isObjectProperty(node) || node.computed)) {
@@ -119,5 +130,54 @@ function configureViteFile(path, check = false) {
   }
   return true;
 }
+function resolvePluginArrays(value, setup) {
+  value = unwrapType(value);
+  if (types.isCallExpression(value) && types.isMemberExpression(value.callee) && !value.callee.computed && types.isIdentifier(value.callee.property, { name: "filter" }) && value.arguments.length === 1 && types.isIdentifier(value.arguments[0], { name: "Boolean" })) value = unwrapType(value.callee.object);
+  if (setup.length === 0 && types.isArrayExpression(value)) return [{ array: value, conditions: [] }];
+  if (!types.isIdentifier(value)) throw new Error("Unsupported dynamic plugins reference");
+  const name = value.name;
+  const declarations = setup.filter((statement) => types.isVariableDeclaration(statement) && statement.declarations.some((item) => types.isIdentifier(item.id, { name })));
+  const first = declarations.length === 1 ? declarations[0] : void 0;
+  if (!types.isVariableDeclaration(first, { kind: "const" }) || first.declarations.length !== 1) {
+    throw new Error("Unsupported plugins initializer");
+  }
+  const declaration = first.declarations[0];
+  const initial = declaration.init && unwrapType(declaration.init);
+  if (!types.isIdentifier(declaration.id, { name }) || !types.isArrayExpression(initial)) {
+    throw new Error("Unsupported plugins initializer");
+  }
+  const arrays = [{ array: initial, conditions: [] }];
+  const visit = (statement, conditions) => {
+    if (types.isVariableDeclaration(statement) && !referencesArray(statement, name)) return;
+    if (types.isIfStatement(statement)) {
+      if (referencesArray(statement.test, name)) throw new Error("Unsupported plugins mutation in condition");
+      visit(statement.consequent, [...conditions, { node: statement, branch: true }]);
+      if (statement.alternate) visit(statement.alternate, [...conditions, { node: statement, branch: false }]);
+      return;
+    }
+    if (types.isBlockStatement(statement)) {
+      statement.body.forEach((child) => visit(child, conditions));
+      return;
+    }
+    const call = types.isExpressionStatement(statement) ? statement.expression : void 0;
+    if (!types.isCallExpression(call) || !types.isMemberExpression(call.callee) || call.callee.computed || !types.isIdentifier(call.callee.object, { name }) || !types.isIdentifier(call.callee.property, { name: "push" }) || call.arguments.some((argument) => types.isJSXNamespacedName(argument) || types.isArgumentPlaceholder(argument))) {
+      throw new Error("Unsupported plugins mutation");
+    }
+    arrays.push({ array: types.arrayExpression(call.arguments), conditions });
+  };
+  setup.filter((statement) => statement !== first).forEach((statement) => visit(statement, []));
+  return arrays;
+}
+function unwrapType(node) {
+  while (types.isTSAsExpression(node) || types.isTSSatisfiesExpression(node)) node = node.expression;
+  return node;
+}
+function referencesArray(node, name) {
+  let found = false;
+  types.traverseFast(node, (child) => {
+    if (types.isIdentifier(child, { name })) found = true;
+  });
+  return found;
+}
 
 export { configureVite, configureViteFile };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-enter-dev",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "type": "module",
   "private": false,
   "description": "A Vite plugin for development enhancements",