refactor: consolidate duplicated predicates and drop test-only re-export shims

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Dr6XbcGLkM1bE4y1VrdVTw

Author: claude

src/internal/emit-wrappers/emit-intrinsic-simple.ts

@@ -24,7 +24,11 @@ import {
 import { withLeadingCommentsOnFirstFunction } from "./comments.js";
 import { collectCompoundVariantKeys, type EmitIntrinsicContext } from "./emit-intrinsic-helpers.js";
 import { buildPolymorphicTypeParams } from "./jsx-builders.js";
-import { collectIdentifiers } from "../utilities/jscodeshift-utils.js";
+import {
+  collectIdentifiers,
+  identifierName,
+  isIdentifierNamed,
+} from "../utilities/jscodeshift-utils.js";
 import { isMemberExpression } from "../lower-rules/utils.js";
 import { getPositiveWhen, parseVariantWhenToAst } from "./variant-condition.js";
 import { typeContainsPolymorphicAs } from "../utilities/polymorphic-as-detection.js";
@@ -1613,14 +1617,6 @@ function extractPropEqUndefined(expr: ExpressionKind): string | null {
   return null;
 }
 
-function isIdentifierNamed(expr: ExpressionKind, name: string): boolean {
-  return expr.type === "Identifier" && expr.name === name;
-}
-
-function identifierName(expr: ExpressionKind): string | null {
-  return expr.type === "Identifier" ? expr.name : null;
-}
-
 function collectPropsFromPropsMemberAccess(node: ExpressionKind, out: Set<string>): void {
   const visit = (value: unknown): void => {
     if (!value || typeof value !== "object") {

src/internal/emit-wrappers/style-merger.ts

@@ -7,6 +7,7 @@ import type { StyleMergerConfig } from "../../adapter.js";
 import type { InlineStyleProp } from "./types.js";
 import type { WrapperEmitter } from "./wrapper-emitter.js";
 import { mergeAdjacentComplementaryStyleExprs } from "./variant-condition.js";
+import { isUndefinedIdentifier } from "../utilities/jscodeshift-utils.js";
 
 /**
  * Result of emitting style merging logic.
@@ -912,10 +913,6 @@ function isExpressionField(node: unknown, field: string): boolean {
   );
 }
 
-function isUndefinedIdentifier(node: unknown): node is { type: "Identifier"; name: "undefined" } {
-  return getNodeType(node) === "Identifier" && (node as { name?: unknown }).name === "undefined";
-}
-
 function getNodeType(node: unknown): string | undefined {
   if (!node || typeof node !== "object") {
     return undefined;

src/internal/emit-wrappers/type-reference-names.ts

@@ -5,6 +5,7 @@
  */
 import type { ASTNode } from "jscodeshift";
 import jscodeshift from "jscodeshift";
+import { isReactComponentPropsUtilityName } from "../utilities/jscodeshift-utils.js";
 
 export type TypeReferenceName =
   | { kind: "identifier"; name: string }
@@ -194,14 +195,6 @@ function isUtilityTypeReference(typeName: TypeReferenceName | null): boolean {
   );
 }
 
-function isReactComponentPropsUtilityName(name: string): boolean {
-  return (
-    name === "ComponentProps" ||
-    name === "ComponentPropsWithRef" ||
-    name === "ComponentPropsWithoutRef"
-  );
-}
-
 function getTypeQueryExpressionName(exprName: unknown): string | null {
   const node = exprName as
     | {

src/internal/lower-rules/dynamic-helper-call.ts

@@ -16,6 +16,10 @@ import {
   getArrowFnParamBindings,
   getMemberPathFromIdentifier,
   getNodeLocStart,
+  isFunctionNode,
+  isIdentifierNamed,
+  isNumericTsType,
+  patternBindsAnyName,
   resolveIdentifierToPropName,
 } from "../utilities/jscodeshift-utils.js";
 import type { DeclProcessingState } from "./decl-setup.js";
@@ -130,7 +134,10 @@ export function numericIdentifierSetForJsxProp(
   jsxProp: string,
   findJsxPropTsType: (propName: string) => unknown,
 ): ReadonlySet<string> {
-  if (jsxProp === "__props" || !isNumericOrOptionalTsType(findJsxPropTsType(jsxProp))) {
+  if (
+    jsxProp === "__props" ||
+    !isNumericTsType(findJsxPropTsType(jsxProp), { allowOptional: true })
+  ) {
     return new Set();
   }
   const names = new Set([jsxProp]);
@@ -140,30 +147,6 @@ export function numericIdentifierSetForJsxProp(
   return names;
 }
 
-function isNumericOrOptionalTsType(tsType: unknown): boolean {
-  if (!tsType || typeof tsType !== "object") {
-    return false;
-  }
-  const type = tsType as { type?: string; types?: unknown[]; literal?: { value?: unknown } };
-  if (type.type === "TSNumberKeyword") {
-    return true;
-  }
-  if (type.type === "TSLiteralType") {
-    return typeof type.literal?.value === "number";
-  }
-  if (type.type === "TSUnionType" && Array.isArray(type.types)) {
-    return type.types.every((member) => {
-      const memberType = (member as { type?: string } | null)?.type;
-      return (
-        memberType === "TSUndefinedKeyword" ||
-        memberType === "TSNullKeyword" ||
-        isNumericOrOptionalTsType(member)
-      );
-    });
-  }
-  return false;
-}
-
 /**
  * Handles dynamic interpolations inside pseudo-elements (::before / ::after / ::placeholder)
  * by emitting a StyleX dynamic style function whose body wraps the value in the pseudo-element
@@ -693,7 +676,7 @@ function expressionContainsFunctionBindingName(node: unknown, names: ReadonlySet
   }
 
   const record = node as Record<string, unknown>;
-  if (isFunctionLikeNode(record)) {
+  if (isFunctionNode(record)) {
     const params = record.params;
     if (Array.isArray(params) && params.some((param) => patternBindsAnyName(param, names))) {
       return true;
@@ -711,48 +694,6 @@ function expressionContainsFunctionBindingName(node: unknown, names: ReadonlySet
   return false;
 }
 
-function isFunctionLikeNode(node: Record<string, unknown>): boolean {
-  return (
-    node.type === "ArrowFunctionExpression" ||
-    node.type === "FunctionExpression" ||
-    node.type === "FunctionDeclaration" ||
-    node.type === "ObjectMethod" ||
-    node.type === "ClassMethod"
-  );
-}
-
-function patternBindsAnyName(node: unknown, names: ReadonlySet<string>): boolean {
-  if (!node || typeof node !== "object") {
-    return false;
-  }
-  const record = node as Record<string, unknown>;
-  if (record.type === "Identifier") {
-    return typeof record.name === "string" && names.has(record.name);
-  }
-  if (record.type === "RestElement") {
-    return patternBindsAnyName(record.argument, names);
-  }
-  if (record.type === "AssignmentPattern") {
-    return patternBindsAnyName(record.left, names);
-  }
-  if (record.type === "ObjectPattern") {
-    return (
-      Array.isArray(record.properties) &&
-      record.properties.some((prop) => patternBindsAnyName(prop, names))
-    );
-  }
-  if (record.type === "ObjectProperty" || record.type === "Property") {
-    return patternBindsAnyName(record.value, names);
-  }
-  if (record.type === "ArrayPattern") {
-    return (
-      Array.isArray(record.elements) &&
-      record.elements.some((element) => patternBindsAnyName(element, names))
-    );
-  }
-  return false;
-}
-
 type DynamicHelperCallResult = {
   value: ExpressionKind;
   binding: DynamicHelperCallArgument;
@@ -1103,10 +1044,6 @@ function getStyledHelperCall(callExpr: CallExpressionLike): StyledHelperCall | n
   };
 }
 
-function isIdentifierNamed(node: ExpressionKind, name: string): boolean {
-  return node?.type === "Identifier" && node.name === name;
-}
-
 type NullishLogicalExpression = ExpressionKind & {
   type: "LogicalExpression";
   operator: "??";

src/internal/lower-rules/finalize-decl.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import jscodeshift from "jscodeshift";
-import { extractSingleRawCssVarStyleFnProperty } from "./finalize-decl.js";
+import { extractSingleRawCssVarStyleFnProperty } from "./raw-css-var-inlining.js";
 
 const j = jscodeshift.withParser("tsx");
 

src/internal/lower-rules/finalize-decl.ts

@@ -60,7 +60,6 @@ import {
   collectRawCssVarStyleObjectProps,
   collectStyleOverrideProps,
   dropCssVariableDefinitionsFromBucket,
-  extractSingleRawCssVarStyleFnProperty,
   findLocalCustomPropertyFallbackFromRules,
   moveCustomPropertyOnlyBaseToInlineStyles,
   moveUnsafeRawCssVarPropsToInlineStyles,
@@ -74,9 +73,6 @@ import {
   mergeBaseIntoSingleStyleFn,
   mergeVariantBucketsIntoStyleFns,
 } from "./style-fn-merging.js";
-import { replaceIdentifierInAst } from "./ast-style-utils.js";
-
-export { extractSingleRawCssVarStyleFnProperty, replaceIdentifierInAst };
 
 export function finalizeDeclProcessing(ctx: DeclProcessingState): void {
   const {

src/internal/lower-rules/imported-value-resolver.ts

@@ -14,11 +14,11 @@ import { resolveDynamicNode } from "../builtin-handlers.js";
 import { isStylexImportSource } from "../utilities/stylex-import-source.js";
 import { extractRootAndPath, getNodeLocStart } from "../utilities/jscodeshift-utils.js";
 import { literalToStaticValue } from "./types.js";
+import { isCssCalcOperator } from "../builtin-handlers/conditional-css-calc.js";
 import {
   buildCssCalcTemplateExpression,
   buildNegatedCssTokenTemplate,
   hasAdjacentTemplateUnit,
-  isCssCalcOperator,
 } from "./interpolated-calc.js";
 import {
   getSingleSlotStaticParts,

src/internal/lower-rules/inline-styles.ts

@@ -10,7 +10,9 @@ import {
   getArrowFnParamBindings,
   getArrowFnSingleParamName,
   getFunctionBodyExpr,
+  isFunctionNode,
   literalToStaticValue,
+  patternBindsAnyName,
 } from "../utilities/jscodeshift-utils.js";
 import type { ExpressionKind } from "./decl-types.js";
 import {
@@ -464,7 +466,7 @@ export function inlineArrowFunctionBody(j: JSCodeshift, expr: any): ExpressionKi
   if (param?.type === "Identifier") {
     const paramName = param.name;
     return mapAst(cloneAstNode(bodyExpr), (node, recurse) => {
-      if (isFunctionLikeNode(node) && functionBindsAnyName(node, new Set([paramName]))) {
+      if (isFunctionNode(node) && functionBindsAnyName(node, new Set([paramName]))) {
         return node;
       }
       if (node.type === "Identifier" && node.name === paramName) {
@@ -484,7 +486,7 @@ export function inlineArrowFunctionBody(j: JSCodeshift, expr: any): ExpressionKi
   // If there's a default value, wrap with nullish coalescing: props.propName ?? defaultValue
   const bindingNames = new Set(bindings.bindings.keys());
   return mapAst(cloneAstNode(bodyExpr), (node, recurse) => {
-    if (isFunctionLikeNode(node) && functionBindsAnyName(node, bindingNames)) {
+    if (isFunctionNode(node) && functionBindsAnyName(node, bindingNames)) {
       return node;
     }
     if (node.type === "Identifier" && bindings.bindings.has(node.name as string)) {
@@ -626,53 +628,11 @@ function makePropsWithThemeObject(j: JSCodeshift) {
   return j.objectExpression([j.spreadElement(j.identifier("props")), themeProperty]);
 }
 
-function isFunctionLikeNode(node: Record<string, unknown>): boolean {
-  return (
-    node.type === "ArrowFunctionExpression" ||
-    node.type === "FunctionExpression" ||
-    node.type === "FunctionDeclaration" ||
-    node.type === "ObjectMethod" ||
-    node.type === "ClassMethod"
-  );
-}
-
 function functionBindsAnyName(node: Record<string, unknown>, names: ReadonlySet<string>): boolean {
   const params = node.params;
   return Array.isArray(params) && params.some((param) => patternBindsAnyName(param, names));
 }
 
-function patternBindsAnyName(node: unknown, names: ReadonlySet<string>): boolean {
-  if (!node || typeof node !== "object") {
-    return false;
-  }
-  const record = node as Record<string, unknown>;
-  if (record.type === "Identifier") {
-    return typeof record.name === "string" && names.has(record.name);
-  }
-  if (record.type === "RestElement") {
-    return patternBindsAnyName(record.argument, names);
-  }
-  if (record.type === "AssignmentPattern") {
-    return patternBindsAnyName(record.left, names);
-  }
-  if (record.type === "ObjectPattern") {
-    return (
-      Array.isArray(record.properties) &&
-      record.properties.some((prop) => patternBindsAnyName(prop, names))
-    );
-  }
-  if (record.type === "ObjectProperty" || record.type === "Property") {
-    return patternBindsAnyName(record.value, names);
-  }
-  if (record.type === "ArrayPattern") {
-    return (
-      Array.isArray(record.elements) &&
-      record.elements.some((element) => patternBindsAnyName(element, names))
-    );
-  }
-  return false;
-}
-
 function collectCurriedCallKeys(node: unknown): Set<string> {
   const keys = new Set<string>();
   walkAst(node, (rec) => {

src/internal/lower-rules/interpolated-calc.ts

@@ -59,10 +59,6 @@ export function buildFullInterpolatedDeclarationValueExpr(
   return j.templateLiteral(quasis, expressions);
 }
 
-export function isCssCalcOperator(operator: string | undefined): boolean {
-  return operator === "+" || operator === "-" || operator === "*" || operator === "/";
-}
-
 export function buildCssCalcTemplateExpression(args: {
   j: JSCodeshift;
   operator: string;

src/internal/lower-rules/numeric-css-props.ts

@@ -202,23 +202,6 @@ export function buildObservedExpressionFallbackValueExpr(args: {
     : rewritten;
 }
 
-export function isNumberLikeTsType(tsType: unknown): boolean {
-  if (!tsType || typeof tsType !== "object") {
-    return false;
-  }
-  const type = tsType as { type?: string; types?: unknown[]; literal?: { value?: unknown } };
-  if (type.type === "TSNumberKeyword") {
-    return true;
-  }
-  if (type.type === "TSLiteralType") {
-    return typeof type.literal?.value === "number";
-  }
-  if (type.type === "TSUnionType" && Array.isArray(type.types)) {
-    return type.types.length > 0 && type.types.every(isNumberLikeTsType);
-  }
-  return false;
-}
-
 const UNITLESS_NUMERIC_STYLEX_PROPS = new Set([
   "animationIterationCount",
   "aspectRatio",