@homebound/truss 2.0.4 → 2.0.6

package/build/plugin/index.js

@@ -1238,6 +1238,13 @@ import _generate from "@babel/generator";
 import * as t3 from "@babel/types";
 var generate = _generate.default ?? _generate;
 var traverse = _traverse.default ?? _traverse;
+function formatDroppedPropertyKey(prop) {
+  if (t3.isObjectProperty(prop)) {
+    if (t3.isIdentifier(prop.key)) return prop.key.name;
+    if (t3.isStringLiteral(prop.key)) return prop.key.value;
+  }
+  return formatNodeSnippet(prop);
+}
 function rewriteExpressionSites(options) {
   for (const site of options.sites) {
     const propsArgs = buildPropsArgsFromChain(site.resolvedChain, options);
@@ -1259,8 +1266,18 @@ function rewriteExpressionSites(options) {
     }
     site.path.replaceWith(buildStyleArrayExpression(propsArgs, site.path.node.loc?.start.line ?? null, options));
   }
-  rewriteCssSpreadCalls(options.ast, options.cssBindingName);
-  rewriteStyleObjectExpressions(options.ast);
+  rewriteCssSpreadCalls(
+    options.ast,
+    options.cssBindingName,
+    options.asStyleArrayHelperName,
+    options.needsAsStyleArrayHelper
+  );
+  rewriteStyleObjectExpressions(
+    options.ast,
+    options.skippedCssPropMessages,
+    options.asStyleArrayHelperName,
+    options.needsAsStyleArrayHelper
+  );
   rewriteCssAttributeExpressions(
     options.ast,
     options.filename,
@@ -1338,7 +1355,7 @@ function buildPropsArgs(segments, options) {
     if (seg.styleArrayArg) {
       args.push(
         t3.spreadElement(
-          buildUnknownObjectSpreadFallback(
+          buildUnknownSpreadFallback(
             seg.styleArrayArg,
             options.asStyleArrayHelperName,
             options.needsAsStyleArrayHelper
@@ -1377,13 +1394,6 @@ function rewriteCssAttributeExpressions(ast, filename, debug, stylexNamespaceNam
       const value = path.node.value;
       if (!t3.isJSXExpressionContainer(value)) return;
       if (!t3.isExpression(value.expression)) return;
-      if (!isCssRewriteableExpression(value.expression, path)) {
-        skippedCssPropMessages.push({
-          message: explainSkippedCssRewrite(value.expression, path),
-          line: path.node.loc?.start.line ?? null
-        });
-        return;
-      }
       const propsArgs = lowerCssExpressionToPropsArgs(
         value.expression,
         path,
@@ -1447,11 +1457,8 @@ function buildDebugElements(line, options) {
   options.needsTrussDebugInfo.current = true;
   return [t3.newExpression(t3.identifier(options.trussDebugInfoName), [t3.stringLiteral(`${options.filename}:${line}`)])];
 }
-function isCssRewriteableExpression(expr, path) {
-  return !!lowerCssExpressionToPropsArgs(expr, path, "asStyleArray", { current: false });
-}
 function lowerCssExpressionToPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  return buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildUnknownCssValuePropsArgs(expr, asStyleArrayHelperName, needsAsStyleArrayHelper);
+  return buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) ?? buildStyleArrayLikePropsArgsFromExpression(expr, path);
 }
 function explainSkippedCssRewrite(expr, path) {
   if (t3.isObjectExpression(expr)) {
@@ -1459,7 +1466,7 @@ function explainSkippedCssRewrite(expr, path) {
       if (!t3.isSpreadElement(prop)) {
         return `[truss] Unsupported pattern: Could not rewrite css prop: object contains a non-spread property (${formatNodeSnippet(expr)})`;
       }
-      const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
+      const normalizedArg = normalizeStyleExpression(prop.argument);
       if (!normalizedArg) {
         return `[truss] Unsupported pattern: Could not rewrite css prop: spread argument is not style-array-like (${formatNodeSnippet(prop.argument)})`;
       }
@@ -1503,51 +1510,46 @@ function removeExistingClassNameAttribute(path) {
 }
 function buildStyleObjectPropsArgs(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   if (!t3.isObjectExpression(expr) || expr.properties.length === 0) return null;
-  const propsArgs = [];
-  for (const prop of expr.properties) {
-    if (!t3.isSpreadElement(prop)) return null;
-    const normalizedArg = normalizeStyleArrayLikeExpression(prop.argument, path, /* @__PURE__ */ new Set());
-    if (!normalizedArg) {
-      propsArgs.push(
-        t3.spreadElement(
-          buildUnknownObjectSpreadFallback(prop.argument, asStyleArrayHelperName, needsAsStyleArrayHelper)
-        )
-      );
-      continue;
-    }
-    const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path, /* @__PURE__ */ new Set());
-    if (nestedArgs && t3.isArrayExpression(normalizedArg)) {
-      propsArgs.push(...nestedArgs);
-    } else {
-      propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
-    }
-  }
-  return propsArgs.length > 0 ? propsArgs : null;
+  const allSpreads = expr.properties.every(function(prop) {
+    return t3.isSpreadElement(prop);
+  });
+  if (!allSpreads) return null;
+  if (hasStyleArraySpread(expr, path)) {
+    const result = flattenStyleObject(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+    return result.elements.filter(Boolean);
+  }
+  return expr.properties.map(function(prop) {
+    const spread = prop;
+    return t3.spreadElement(
+      buildUnknownSpreadFallback(spread.argument, asStyleArrayHelperName, needsAsStyleArrayHelper)
+      // I.e. `css={{ ...css }}` or `css={{ ...xss }}`
+    );
+  });
 }
-function buildStyleArrayLikePropsArgsFromExpression(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  const normalizedExpr = normalizeStyleArrayLikeExpression(expr, path, /* @__PURE__ */ new Set());
+function buildStyleArrayLikePropsArgsFromExpression(expr, path) {
+  const normalizedExpr = normalizeStyleExpression(expr);
   if (!normalizedExpr) return null;
-  return buildStyleArrayLikePropsArgs(normalizedExpr, path, /* @__PURE__ */ new Set());
+  return buildStyleArrayLikePropsArgs(normalizedExpr, path);
 }
-function buildStyleArrayLikePropsArgs(expr, path, seen) {
-  if (seen.has(expr)) return null;
-  seen.add(expr);
+function buildStyleArrayLikePropsArgs(expr, path) {
   if (t3.isArrayExpression(expr)) {
     const propsArgs = [];
     for (const el of expr.elements) {
       if (!el) continue;
       if (t3.isSpreadElement(el)) {
-        const normalizedArg = normalizeStyleArrayLikeExpression(el.argument, path, /* @__PURE__ */ new Set());
+        const normalizedArg = normalizeStyleExpression(el.argument);
         if (!normalizedArg) {
           propsArgs.push(t3.spreadElement(el.argument));
           continue;
         }
-        const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path, seen);
-        if (nestedArgs && t3.isArrayExpression(normalizedArg)) {
-          propsArgs.push(...nestedArgs);
-        } else {
-          propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
+        if (t3.isArrayExpression(normalizedArg)) {
+          const nestedArgs = buildStyleArrayLikePropsArgs(normalizedArg, path);
+          if (nestedArgs) {
+            propsArgs.push(...nestedArgs);
+            continue;
+          }
         }
+        propsArgs.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
         continue;
       }
       propsArgs.push(el);
@@ -1559,20 +1561,22 @@ function buildStyleArrayLikePropsArgs(expr, path, seen) {
   }
   return null;
 }
-function buildUnknownCssValuePropsArgs(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
-  if (!(t3.isIdentifier(expr) || t3.isMemberExpression(expr) || t3.isCallExpression(expr))) return null;
-  return [t3.spreadElement(buildUnknownObjectSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper))];
-}
-function rewriteStyleObjectExpressions(ast) {
+function rewriteStyleObjectExpressions(ast, messages, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   traverse(ast, {
     ObjectExpression(path) {
-      const rewritten = tryBuildStyleArrayFromObject(path);
-      if (!rewritten) return;
-      path.replaceWith(rewritten);
+      if (!hasStyleArraySpread(path.node, path)) return;
+      const result = flattenStyleObject(path.node, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+      if (result.droppedPropertyKeys.length > 0) {
+        messages.push({
+          message: `[truss] Unsupported pattern: Dropped non-spread properties from style composition object (${result.droppedPropertyKeys.join(", ")})`,
+          line: path.node.loc?.start.line ?? null
+        });
+      }
+      path.replaceWith(t3.arrayExpression(result.elements));
     }
   });
 }
-function rewriteCssSpreadCalls(ast, cssBindingName) {
+function rewriteCssSpreadCalls(ast, cssBindingName, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   traverse(ast, {
     CallExpression(path) {
       if (!isCssSpreadCall(path.node, cssBindingName)) return;
@@ -1580,180 +1584,148 @@ function rewriteCssSpreadCalls(ast, cssBindingName) {
       if (!arg || t3.isSpreadElement(arg) || !t3.isExpression(arg) || path.node.arguments.length !== 1) return;
       const styleObject = unwrapStyleObjectExpression(arg);
       if (!styleObject) return;
-      const rewritten = tryBuildStyleArrayFromObjectExpression(styleObject, path);
-      if (!rewritten) return;
-      path.replaceWith(rewritten);
+      if (!hasStyleArraySpread(styleObject, path)) return;
+      const result = flattenStyleObject(styleObject, path, asStyleArrayHelperName, needsAsStyleArrayHelper);
+      path.replaceWith(t3.arrayExpression(result.elements));
     }
   });
 }
-function tryBuildStyleArrayFromObject(path) {
-  return tryBuildStyleArrayFromObjectExpression(path.node, path);
-}
-function tryBuildStyleArrayFromObjectExpression(expr, path) {
-  if (expr.properties.length === 0) return null;
-  let sawStyleArray = false;
+function flattenStyleObject(expr, path, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   const elements = [];
+  const droppedPropertyKeys = [];
   for (const prop of expr.properties) {
     if (!t3.isSpreadElement(prop)) {
-      return null;
-    }
-    const normalizedArg = normalizeStyleArrayLikeExpression(
-      prop.argument,
-      path,
-      /* @__PURE__ */ new Set()
-      // I.e. `...Css.df.$`, `...(cond ? Css.df.$ : {})`, or `...styles.wrapper`
-    );
-    if (!normalizedArg) {
-      elements.push(t3.spreadElement(buildInlineAsStyleArrayExpression(prop.argument)));
+      droppedPropertyKeys.push(formatDroppedPropertyKey(prop));
       continue;
     }
-    if (isKnownStyleArrayLike(normalizedArg, path, /* @__PURE__ */ new Set())) {
-      sawStyleArray = true;
-    }
-    if (t3.isArrayExpression(normalizedArg)) {
-      elements.push(...normalizedArg.elements);
+    const normalized = normalizeStyleExpression(prop.argument);
+    if (!normalized) {
+      elements.push(
+        t3.spreadElement(buildUnknownSpreadFallback(prop.argument, asStyleArrayHelperName, needsAsStyleArrayHelper))
+      );
       continue;
     }
-    elements.push(t3.spreadElement(buildSafeSpreadArgument(normalizedArg)));
+    if (t3.isArrayExpression(normalized)) {
+      elements.push(...normalized.elements);
+    } else if (expressionContainsArray(normalized, path)) {
+      elements.push(t3.spreadElement(buildSafeSpreadArgument(normalized)));
+    } else {
+      elements.push(
+        t3.spreadElement(buildUnknownSpreadFallback(normalized, asStyleArrayHelperName, needsAsStyleArrayHelper))
+        // I.e. `...borderBottomStyles`
+      );
+    }
   }
-  if (!sawStyleArray) return null;
-  return t3.arrayExpression(elements);
+  return { elements, droppedPropertyKeys };
 }
-function isCssSpreadCall(expr, cssBindingName) {
-  return t3.isMemberExpression(expr.callee) && !expr.callee.computed && t3.isIdentifier(expr.callee.object, { name: cssBindingName }) && t3.isIdentifier(expr.callee.property, { name: "spread" });
+function hasStyleArraySpread(expr, path) {
+  return expr.properties.some(function(prop) {
+    return t3.isSpreadElement(prop) && expressionContainsArray(prop.argument, path);
+  });
 }
-function unwrapStyleObjectExpression(expr) {
-  if (t3.isObjectExpression(expr)) return expr;
-  if (t3.isTSAsExpression(expr) || t3.isTSSatisfiesExpression(expr) || t3.isTSNonNullExpression(expr)) {
-    return unwrapStyleObjectExpression(expr.expression);
+function expressionContainsArray(expr, path) {
+  if (t3.isArrayExpression(expr)) return true;
+  if (t3.isConditionalExpression(expr)) {
+    return expressionContainsArray(expr.consequent, path) || expressionContainsArray(expr.alternate, path);
   }
-  return null;
+  if (t3.isLogicalExpression(expr)) {
+    return expressionContainsArray(expr.left, path) || expressionContainsArray(expr.right, path);
+  }
+  if (t3.isObjectExpression(expr)) {
+    return expr.properties.some(function(p) {
+      return t3.isSpreadElement(p) && expressionContainsArray(p.argument, path);
+    });
+  }
+  if (t3.isIdentifier(expr)) {
+    const binding = path.scope.getBinding(expr.name);
+    if (binding?.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (init) return expressionContainsArray(init, binding.path);
+    }
+    return false;
+  }
+  if (t3.isMemberExpression(expr) && t3.isIdentifier(expr.object)) {
+    const binding = path.scope.getBinding(expr.object.name);
+    if (binding?.path.isVariableDeclarator()) {
+      const init = binding.path.node.init;
+      if (init && t3.isObjectExpression(init)) {
+        const propName = getStaticMemberPropertyName(expr, path);
+        if (propName) {
+          for (const prop of init.properties) {
+            if (!t3.isObjectProperty(prop) || prop.computed) continue;
+            if (!isMatchingPropertyName(prop.key, propName)) continue;
+            if (t3.isExpression(prop.value)) {
+              return expressionContainsArray(prop.value, binding.path);
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+  if (t3.isCallExpression(expr)) {
+    const returnExpr = getCallReturnExpression(expr, path);
+    return returnExpr ? expressionContainsArray(returnExpr, path) : false;
+  }
+  return false;
 }
-function normalizeStyleArrayLikeExpression(expr, path, seen) {
-  if (seen.has(expr)) return null;
-  seen.add(expr);
+function normalizeStyleExpression(expr) {
   if (t3.isArrayExpression(expr)) return expr;
+  if (isEmptyObjectExpression(expr)) return t3.arrayExpression([]);
   if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    const consequent = normalizeStyleArrayLikeExpression(expr.right, path, seen);
+    const consequent = normalizeStyleExpression(expr.right);
     if (!consequent) return null;
     return t3.conditionalExpression(expr.left, consequent, t3.arrayExpression([]));
   }
   if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    const left = normalizeStyleArrayLikeExpression(expr.left, path, seen);
-    const right = normalizeStyleArrayLikeBranch(expr.right, path, seen);
+    const left = normalizeStyleExpression(expr.left);
+    const right = normalizeStyleBranch(expr.right);
     if (!left || !right) return null;
     return t3.logicalExpression(expr.operator, left, right);
   }
   if (t3.isConditionalExpression(expr)) {
-    const consequent = normalizeStyleArrayLikeBranch(expr.consequent, path, seen);
-    const alternate = normalizeStyleArrayLikeBranch(expr.alternate, path, seen);
+    const consequent = normalizeStyleBranch(expr.consequent);
+    const alternate = normalizeStyleBranch(expr.alternate);
     if (!consequent || !alternate) return null;
     return t3.conditionalExpression(expr.test, consequent, alternate);
   }
   if (t3.isIdentifier(expr) || t3.isMemberExpression(expr) || t3.isCallExpression(expr)) {
-    const nestedSeen = new Set(seen);
-    nestedSeen.delete(expr);
-    if (isStyleArrayLike(expr, path, nestedSeen)) return expr;
+    return expr;
   }
   return null;
 }
-function normalizeStyleArrayLikeBranch(expr, path, seen) {
-  if (isEmptyObjectExpression(expr)) {
-    return t3.arrayExpression([]);
-  }
+function normalizeStyleBranch(expr) {
+  if (isEmptyObjectExpression(expr)) return t3.arrayExpression([]);
   if (t3.isObjectExpression(expr)) {
-    return tryBuildStyleArrayFromObjectExpression(expr, path);
-  }
-  return normalizeStyleArrayLikeExpression(expr, path, seen);
-}
-function isStyleArrayLike(expr, path, seen) {
-  if (seen.has(expr)) return false;
-  seen.add(expr);
-  if (t3.isArrayExpression(expr)) return true;
-  if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    return isStyleArrayLike(expr.right, path, seen);
-  }
-  if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    return isStyleArrayLike(expr.left, path, seen) && isStyleArrayLikeBranch(expr.right, path, seen);
-  }
-  if (t3.isConditionalExpression(expr)) {
-    return isStyleArrayLikeBranch(expr.consequent, path, seen) && isStyleArrayLikeBranch(expr.alternate, path, seen);
-  }
-  if (t3.isIdentifier(expr)) {
-    const binding = path.scope.getBinding(expr.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    return !!(init && isStyleArrayLike(init, bindingPath, seen));
-  }
-  if (t3.isCallExpression(expr)) {
-    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
-    return returnExpr ? isStyleArrayLike(returnExpr, path, seen) : true;
-  }
-  if (t3.isMemberExpression(expr)) {
-    const object = expr.object;
-    if (!t3.isIdentifier(object)) return false;
-    const binding = path.scope.getBinding(object.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    if (!init || !t3.isObjectExpression(init)) return false;
-    const propertyName = getStaticMemberPropertyName(expr, path);
-    if (!propertyName) return false;
-    for (const prop of init.properties) {
-      if (!t3.isObjectProperty(prop) || prop.computed) continue;
-      if (!isMatchingPropertyName(prop.key, propertyName)) continue;
-      const value = prop.value;
-      return t3.isExpression(value) && isStyleArrayLike(value, bindingPath, seen);
+    if (expr.properties.length === 0) return t3.arrayExpression([]);
+    const allSpreads = expr.properties.every(function(p) {
+      return t3.isSpreadElement(p);
+    });
+    if (!allSpreads) return null;
+    const elements = [];
+    for (const prop of expr.properties) {
+      const spread = prop;
+      const normalized = normalizeStyleExpression(spread.argument);
+      if (!normalized) return null;
+      if (t3.isArrayExpression(normalized)) {
+        elements.push(...normalized.elements);
+      } else {
+        elements.push(t3.spreadElement(buildSafeSpreadArgument(normalized)));
+      }
     }
+    return t3.arrayExpression(elements);
   }
-  return false;
+  return normalizeStyleExpression(expr);
 }
-function isKnownStyleArrayLike(expr, path, seen) {
-  if (seen.has(expr)) return false;
-  seen.add(expr);
-  if (t3.isArrayExpression(expr)) return true;
-  if (t3.isLogicalExpression(expr) && expr.operator === "&&") {
-    return isKnownStyleArrayLike(expr.right, path, seen);
-  }
-  if (t3.isLogicalExpression(expr) && (expr.operator === "||" || expr.operator === "??")) {
-    return isKnownStyleArrayLike(expr.left, path, seen) && isStyleArrayLikeBranch(expr.right, path, seen);
-  }
-  if (t3.isConditionalExpression(expr)) {
-    return isStyleArrayLikeBranch(expr.consequent, path, seen) && isStyleArrayLikeBranch(expr.alternate, path, seen);
-  }
-  if (t3.isIdentifier(expr)) {
-    const binding = path.scope.getBinding(expr.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    return !!(init && isKnownStyleArrayLike(init, bindingPath, seen));
-  }
-  if (t3.isCallExpression(expr)) {
-    const returnExpr = getCallStyleArrayLikeExpression(expr, path);
-    return !!(returnExpr && isKnownStyleArrayLike(returnExpr, path, seen));
-  }
-  if (t3.isMemberExpression(expr)) {
-    const object = expr.object;
-    if (!t3.isIdentifier(object)) return false;
-    const binding = path.scope.getBinding(object.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return false;
-    const init = bindingPath.node.init;
-    if (!init || !t3.isObjectExpression(init)) return false;
-    const propertyName = getStaticMemberPropertyName(expr, path);
-    if (!propertyName) return false;
-    for (const prop of init.properties) {
-      if (!t3.isObjectProperty(prop) || prop.computed) continue;
-      if (!isMatchingPropertyName(prop.key, propertyName)) continue;
-      const value = prop.value;
-      return t3.isExpression(value) && isKnownStyleArrayLike(value, bindingPath, seen);
-    }
-  }
-  return false;
+function isCssSpreadCall(expr, cssBindingName) {
+  return t3.isMemberExpression(expr.callee) && !expr.callee.computed && t3.isIdentifier(expr.callee.object, { name: cssBindingName }) && t3.isIdentifier(expr.callee.property, { name: "spread" });
 }
-function isStyleArrayLikeBranch(expr, path, seen) {
-  return isEmptyObjectExpression(expr) || isStyleArrayLike(expr, path, seen);
+function unwrapStyleObjectExpression(expr) {
+  if (t3.isObjectExpression(expr)) return expr;
+  if (t3.isTSAsExpression(expr) || t3.isTSSatisfiesExpression(expr) || t3.isTSNonNullExpression(expr)) {
+    return unwrapStyleObjectExpression(expr.expression);
+  }
+  return null;
 }
 function isMatchingPropertyName(key, name) {
   return t3.isIdentifier(key) && key.name === name || t3.isStringLiteral(key) && key.value === name;
@@ -1761,17 +1733,10 @@ function isMatchingPropertyName(key, name) {
 function isEmptyObjectExpression(expr) {
   return t3.isObjectExpression(expr) && expr.properties.length === 0;
 }
-function buildUnknownObjectSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
+function buildUnknownSpreadFallback(expr, asStyleArrayHelperName, needsAsStyleArrayHelper) {
   needsAsStyleArrayHelper.current = true;
   return t3.callExpression(t3.identifier(asStyleArrayHelperName), [expr]);
 }
-function buildInlineAsStyleArrayExpression(expr) {
-  return t3.conditionalExpression(
-    t3.callExpression(t3.memberExpression(t3.identifier("Array"), t3.identifier("isArray")), [expr]),
-    expr,
-    t3.conditionalExpression(expr, t3.arrayExpression([expr]), t3.arrayExpression([]))
-  );
-}
 function buildSafeSpreadArgument(expr) {
   return t3.isConditionalExpression(expr) || t3.isLogicalExpression(expr) ? t3.parenthesizedExpression(expr) : expr;
 }
@@ -1784,14 +1749,13 @@ function getStaticMemberPropertyName(expr, path) {
   }
   if (t3.isIdentifier(expr.property)) {
     const binding = path.scope.getBinding(expr.property.name);
-    const bindingPath = binding?.path;
-    if (!bindingPath || !bindingPath.isVariableDeclarator()) return null;
-    const init = bindingPath.node.init;
+    if (!binding?.path.isVariableDeclarator()) return null;
+    const init = binding.path.node.init;
     return t3.isStringLiteral(init) ? init.value : null;
   }
   return null;
 }
-function getCallStyleArrayLikeExpression(expr, path) {
+function getCallReturnExpression(expr, path) {
   const localReturnExpr = getLocalFunctionReturnExpression(expr, path);
   if (localReturnExpr) return localReturnExpr;
   const firstArg = expr.arguments[0];
@@ -1803,13 +1767,12 @@ function getCallStyleArrayLikeExpression(expr, path) {
 function getLocalFunctionReturnExpression(expr, path) {
   if (!t3.isIdentifier(expr.callee)) return null;
   const binding = path.scope.getBinding(expr.callee.name);
-  const bindingPath = binding?.path;
-  if (!bindingPath) return null;
-  if (bindingPath.isFunctionDeclaration()) {
-    return getFunctionLikeReturnExpression(bindingPath.node);
+  if (!binding) return null;
+  if (binding.path.isFunctionDeclaration()) {
+    return getFunctionLikeReturnExpression(binding.path.node);
   }
-  if (bindingPath.isVariableDeclarator()) {
-    const init = bindingPath.node.init;
+  if (binding.path.isVariableDeclarator()) {
+    const init = binding.path.node.init;
     if (init && (t3.isArrowFunctionExpression(init) || t3.isFunctionExpression(init))) {
       return getFunctionLikeReturnExpression(init);
     }