@astryxdesign/cli 0.6.3-canary.d0d49a4 → 0.6.3-canary.db4e378

package/assets/codemods/transforms/v0.0.14/__tests__/rename-status-variants.test.mjs

@@ -1,205 +1,126 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
-import {describe, it, expect} from 'vitest';
+import {describe, expect, it} from 'vitest';
+import transform from '../rename-status-variants.mjs';
 
 async function applyTransform(source) {
-  const {default: transform} = await import(
-    '../rename-status-variants.mjs'
-  );
   const jscodeshift = (await import('jscodeshift')).default;
   const j = jscodeshift.withParser('tsx');
   const api = {jscodeshift: j, stats: () => {}, report: () => {}};
-  const file = {source, path: 'test.tsx'};
-  const result = transform(file, api);
-  return result ?? source;
+  return transform({source, path: 'test.tsx'}, api) ?? source;
 }
 
 describe('rename-status-variants', () => {
-  it('renames StatusDot variant="positive" to "success"', async () => {
-    const input = `<XDSStatusDot variant="positive" label="Online" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
-  });
+  it('renames direct StatusDot literals and ternary branches', async () => {
+    const output = await applyTransform(`import {StatusDot} from '@astryxdesign/core';
+const a = <StatusDot variant="positive" />;
+const b = <StatusDot variant={'negative'} />;
+const c = <StatusDot variant={ready ? 'info' : 'positive'} />;`);
 
-  it('renames StatusDot variant="negative" to "error"', async () => {
-    const input = `<XDSStatusDot variant="negative" label="Offline" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'negative'");
+    expect(output).toContain("variant='success'");
+    expect(output).toContain("variant={'error'}");
+    expect(output).toContain("ready ? 'accent' : 'success'");
   });
 
-  it('renames StatusDot variant="info" to "accent"', async () => {
-    const input = `<XDSStatusDot variant="info" label="Info" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'accent'");
-    expect(output).not.toContain("'info'");
-  });
+  it('renames literals inside satisfies expressions while preserving the type', async () => {
+    const output =
+      await applyTransform(`import {StatusDot} from '@astryxdesign/core';
+const view = <StatusDot variant={'positive' satisfies StatusDotVariant} />;`);
 
-  it('renames AvatarStatusDot variant="positive" to "success"', async () => {
-    const input = `<XDSAvatarStatusDot variant="positive" label="Online" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
+    expect(output).toContain("{'success' satisfies StatusDotVariant}");
   });
 
-  it('renames Icon color="positive" to "success"', async () => {
-    const input = `<XDSIcon color="positive" icon={CheckIcon} />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
-  });
+  it('renames Icon, SVGIcon, AvatarStatusDot, and ProgressBar props', async () => {
+    const output = await applyTransform(`import {
+  Icon,
+  SVGIcon,
+  AvatarStatusDot,
+  ProgressBar,
+} from '@astryxdesign/core';
+const view = <>
+  <Icon color="negative" />
+  <SVGIcon color="positive" />
+  <AvatarStatusDot variant="negative" />
+  <ProgressBar variant="positive" />
+</>;`);
 
-  it('renames Icon color="negative" to "error"', async () => {
-    const input = `<XDSIcon color="negative" icon={XIcon} />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'negative'");
+    expect(output.match(/'error'/g)).toHaveLength(2);
+    expect(output.match(/'success'/g)).toHaveLength(2);
   });
 
-  it('renames ProgressBar variant="positive" to "success"', async () => {
-    const input = `<XDSProgressBar variant="positive" value={50} />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
-  });
+  it('maps import aliases and default subpath imports', async () => {
+    const output = await applyTransform(`import {StatusDot as Dot} from '@xds/core';
+import IconGlyph from '@astryxdesign/core/Icon';
+const view = <><Dot variant="positive" /><IconGlyph color="negative" /></>;`);
 
-  it('renames ProgressBar variant="negative" to "error"', async () => {
-    const input = `<XDSProgressBar variant="negative" value={50} />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'negative'");
+    expect(output).toContain("<Dot variant='success'");
+    expect(output).toContain("<IconGlyph color='error'");
   });
 
-  it('handles expression container: variant={"positive"}', async () => {
-    const input = `<XDSStatusDot variant={'positive'} label="Online" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
-  });
+  it('maps namespace imports', async () => {
+    const output = await applyTransform(`import * as Core from '@astryxdesign/core';
+const view = <Core.StatusDot variant="info" />;`);
 
-  it('handles ternary: variant={x ? "positive" : "negative"}', async () => {
-    const input = `<XDSStatusDot variant={isOnline ? 'positive' : 'negative'} label="Status" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'positive'");
-    expect(output).not.toContain("'negative'");
+    expect(output).toContain("variant='accent'");
   });
 
-  it('renames object property values in files importing target components', async () => {
-    const input = `import { XDSStatusDot } from '@xds/core/StatusDot';
-const args = { variant: 'positive' };`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).not.toContain("'positive'");
-  });
+  it('keeps Badge info distinct while renaming its removed variants', async () => {
+    const output = await applyTransform(`import {Badge} from '@astryxdesign/core';
+const view = <>
+  <Badge variant="info" />
+  <Badge variant="positive" />
+  <Badge variant="negative" />
+</>;`);
 
-  it('renames unambiguous values in Storybook argType options arrays but leaves ambiguous "info"', async () => {
-    const input = `import { XDSStatusDot } from '@xds/core/StatusDot';
-const meta = { argTypes: { variant: { options: ['positive', 'negative', 'warning', 'info', 'neutral'] } } };`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'positive'");
-    expect(output).not.toContain("'negative'");
-    // 'info' is ambiguous (valid on Badge etc.) and this is a context-blind
-    // path — the codemod cannot tell which component the options describe, so
-    // it is left for human review rather than risk rewriting a valid value.
-    expect(output).toContain("'info'");
-    expect(output).not.toContain("'accent'");
-    // warning and neutral are unchanged
-    expect(output).toContain("'warning'");
-    expect(output).toContain("'neutral'");
+    expect(output).toContain('variant="info"');
+    expect(output).toContain("variant='success'");
+    expect(output).toContain("variant='error'");
   });
 
-  it('does not touch unrelated components', async () => {
-    const input = `<XDSBadge variant="info" label="New" />`;
-    const output = await applyTransform(input);
-    // XDSBadge is not in the target list
-    expect(output).toContain('info');
+  it('leaves variables, helpers, objects, types, and Storybook metadata untouched', async () => {
+    const input = `import {StatusDot} from '@astryxdesign/core';
+type CellTone = 'positive' | 'negative' | 'info';
+const args = {variant: 'positive'};
+const options = ['positive', 'negative', 'info'];
+function tone() { return 'negative' as const; }
+const view = <StatusDot variant={tone()} />;`;
+
+    expect(await applyTransform(input)).toBe(input);
   });
 
-  it('does not rewrite Badge config "info" in a file that also imports a target (Icon)', async () => {
-    // Regression: a file may import a target component (e.g. XDSIcon) AND
-    // declare a typed config object for a NON-target component (Badge, whose
-    // BadgeVariantMap still has `info`). The context-blind object-property path
-    // must NOT rewrite that `info` to `accent` just because the file imports a
-    // target — `accent` is not a valid Badge variant. positive/negative stay
-    // renamed (no component keeps them), but info is preserved.
-    const input = `import { XDSIcon } from '@xds/core/Icon';
-import { XDSBadge, type XDSBadgeVariant } from '@xds/core/Badge';
-const PROGRESS_CONFIG: Record<string, {label: string; variant: XDSBadgeVariant}> = {
-  OPEN: {label: 'Open', variant: 'info'},
-  DONE: {label: 'Done', variant: 'positive'},
-  BLOCKED: {label: 'Blocked', variant: 'negative'},
-};`;
-    const output = await applyTransform(input);
-    // Ambiguous 'info' on a Badge config is left intact.
-    expect(output).toContain("variant: 'info'");
-    expect(output).not.toContain("'accent'");
-    // Unambiguous values are still migrated (no component retains them).
-    expect(output).toContain("variant: 'success'");
-    expect(output).toContain("variant: 'error'");
-    expect(output).not.toContain("'positive'");
-    expect(output).not.toContain("'negative'");
+  it('leaves unrelated props untouched', async () => {
+    const output = await applyTransform(`import {StatusDot} from '@astryxdesign/core';
+const view = <StatusDot variant="positive" label="positive" />;`);
+
+    expect(output).toContain("variant='success'");
+    expect(output).toContain('label="positive"');
   });
 
-  it('still renames "info" to "accent" on a direct target JSX attribute', async () => {
-    // The precise path (component is known) keeps the full mapping, including
-    // the ambiguous info -> accent, even when other components are imported.
-    const input = `import { XDSStatusDot } from '@xds/core/StatusDot';
-import { XDSBadge } from '@xds/core/Badge';
-const a = <XDSStatusDot variant="info" label="Status" />;
-const b = <XDSBadge variant="info" label="New" />;`;
-    const output = await applyTransform(input);
-    // StatusDot's info -> accent (precise), Badge's info stays.
-    expect(output).toContain("<XDSStatusDot variant='accent'");
-    expect(output).toContain('<XDSBadge variant="info"');
+  it('ignores same-named components imported from other packages', async () => {
+    const input = `import {StatusDot} from '@other/core';
+const view = <StatusDot variant="positive" />;`;
+    expect(await applyTransform(input)).toBe(input);
   });
 
-  it('does not touch unrelated props on target components', async () => {
-    const input = `<XDSStatusDot variant="positive" label="positive result" />`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    // The label "positive result" should NOT be renamed
-    expect(output).toContain('positive result');
+  it('ignores a local component that shadows an imported alias', async () => {
+    const output = await applyTransform(`import {StatusDot as Dot} from '@xds/core';
+const migrated = <Dot variant="positive" />;
+function Local(Dot) { return <Dot variant="negative" />; }`);
+
+    expect(output).toContain("variant='success'");
+    expect(output).toContain('variant="negative"');
   });
 
-  it('returns undefined when no changes needed', async () => {
-    const {default: transform} = await import(
-      '../rename-status-variants.mjs'
-    );
+  it('returns undefined when no direct prop needs a change', async () => {
     const jscodeshift = (await import('jscodeshift')).default;
     const j = jscodeshift.withParser('tsx');
-    const api = {jscodeshift: j, stats: () => {}, report: () => {}};
-    const source = `<XDSStatusDot variant='success' label='Online' />`;
-    const result = transform({source, path: 'test.tsx'}, api);
-    expect(result).toBeUndefined();
-  });
-
-  it('handles a full component file', async () => {
-    const input = `import { XDSStatusDot } from '@xds/core/StatusDot';
-import { XDSIcon } from '@xds/core/Icon';
-
-function StatusIndicator({ isOnline }: { isOnline: boolean }) {
-  return (
-    <div>
-      <XDSStatusDot
-        variant={isOnline ? 'positive' : 'negative'}
-        label={isOnline ? 'Online' : 'Offline'}
-      />
-      <XDSIcon
-        icon={isOnline ? CheckIcon : XIcon}
-        color={isOnline ? 'positive' : 'negative'}
-      />
-    </div>
-  );
-}`;
-    const output = await applyTransform(input);
-    expect(output).toContain("'success'");
-    expect(output).toContain("'error'");
-    expect(output).not.toContain("'positive'");
-    expect(output).not.toContain("'negative'");
+    const source = `import {StatusDot} from '@astryxdesign/core';
+const view = <StatusDot variant="success" />;`;
+    expect(
+      transform(
+        {source, path: 'test.tsx'},
+        {jscodeshift: j, stats: () => {}, report: () => {}},
+      ),
+    ).toBeUndefined();
   });
 });

package/assets/codemods/transforms/v0.0.14/rename-status-variants.mjs

@@ -4,86 +4,81 @@
  * @file Codemod: Rename status variants positive/negative → success/error
  * @see https://github.com/facebookexperimental/xds/issues/996
  *
- * Converges component APIs to match the token layer naming:
- * - `positive` → `success` (maps to --color-success)
- * - `negative` → `error` (maps to --color-error)
- * - `info` → `accent` (maps to --color-accent)
- *
- * Affected components:
- * - XDSStatusDot: variant="positive|negative|info" → variant="success|error|accent"
- * - XDSAvatarStatusDot: variant="positive|negative" → variant="success|error"
- * - XDSIcon: color="positive|negative" → color="success|error"
- * - XDSProgressBar: variant="positive|negative" → variant="success|error"
- *
- * Transforms JSX attributes, object properties (in files importing affected
- * components), TypeScript type annotations, and Storybook argType options.
+ * This transform is deliberately limited to static literals written directly
+ * in affected props on imported JSX components. It does not infer through
+ * variables, helpers, objects, types, or wrappers: missing an indirect
+ * migration is safer than rewriting an unrelated domain using the same words.
  */
 
+import {transformProp} from '../../transform-prop.mjs';
+
 export const meta = {
   title: 'Rename status variants positive/negative → success/error',
   description:
-    'Renames `positive` to `success`, `negative` to `error`, and `info` to `accent` ' +
-    'on StatusDot, AvatarStatusDot, Icon, SVGIcon, and ProgressBar to align with token naming. ' +
-    'The `info` -> `accent` rename is only applied to direct JSX attributes on these ' +
-    'components (where the component is known); in context-blind locations (object ' +
-    'properties, type unions) `info` is left untouched because it is a valid variant on ' +
-    'other components such as Badge.',
+    'Renames static status values written directly on imported StatusDot, ' +
+    'AvatarStatusDot, Icon, SVGIcon, ProgressBar, and Badge JSX elements. ' +
+    'Indirect values are left unchanged for manual migration.',
   pr: '#996',
 };
 
-/** Rename mappings. */
-const RENAMES = new Map([
+const CORE_IMPORT_RE = /^@(astryxdesign|xds)\/core(?:\/|$)/;
+
+const COMPONENT_PROPS = new Map([
+  ['StatusDot', new Set(['variant'])],
+  ['AvatarStatusDot', new Set(['variant'])],
+  ['Icon', new Set(['color'])],
+  ['SVGIcon', new Set(['color'])],
+  ['ProgressBar', new Set(['variant'])],
+  ['Badge', new Set(['variant'])],
+]);
+
+const STATUS_RENAMES = new Map([
   ['positive', 'success'],
   ['negative', 'error'],
   ['info', 'accent'],
 ]);
 
-/**
- * Ambiguous renames that are only safe when the target component is known.
- *
- * `info` is a VALID variant on non-target components (notably XDSBadge, whose
- * BadgeVariantMap still has `info`). `positive`/`negative` are not retained by
- * any component post-migration, so renaming them is always safe. Therefore the
- * context-blind heuristic paths (object properties, type unions, and suffixed
- * props on wrapper components) must NOT rewrite `info` — only the precise path,
- * a direct JSX attribute on a known target component, may. Otherwise a
- * `variant: 'info'` on an unrelated Badge config in a file that merely also
- * imports e.g. XDSIcon gets wrongly rewritten to the invalid `accent`.
- */
-const AMBIGUOUS_VALUES = new Set(['info']);
-
-
-/**
- * Components and which props are affected.
- * Key: component name. Value: set of prop names to check.
- */
-const COMPONENT_PROPS = new Map([
-  ['XDSStatusDot', new Set(['variant'])],
-  ['XDSAvatarStatusDot', new Set(['variant'])],
-  ['XDSIcon', new Set(['color'])],
-  ['XDSProgressBar', new Set(['variant'])],
+const BADGE_RENAMES = new Map([
+  ['positive', 'success'],
+  ['negative', 'error'],
 ]);
 
-/** All affected component names for quick lookup. */
-const TARGET_COMPONENTS = new Set(COMPONENT_PROPS.keys());
-
-/** All affected prop names (variant, color). */
-const TARGET_PROP_NAMES = new Set();
-for (const props of COMPONENT_PROPS.values()) {
-  for (const p of props) TARGET_PROP_NAMES.add(p);
+/** @param {string} name */
+function canonicalComponentName(name) {
+  return name.startsWith('XDS') ? name.slice(3) : name;
 }
 
 /**
- * Check if a key matches a target prop — exact or case-insensitive suffix.
- * e.g. "dotVariant" matches because it ends with "variant".
+ * @param {any} node
+ * @param {ReadonlyMap<string, string>} renames
+ * @returns {boolean}
  */
-function matchesPropName(/** @type {any} */ keyName) {
-  if (TARGET_PROP_NAMES.has(keyName)) return true;
-  const lower = keyName.toLowerCase();
-  for (const prop of TARGET_PROP_NAMES) {
-    if (lower.endsWith(prop.toLowerCase()) && lower !== prop.toLowerCase()) return true;
+function renameStaticValue(node, renames) {
+  if (!node) return false;
+  if (
+    node.type === 'TSAsExpression' ||
+    node.type === 'TSSatisfiesExpression' ||
+    node.type === 'TypeCastExpression' ||
+    node.type === 'ParenthesizedExpression'
+  ) {
+    return renameStaticValue(node.expression, renames);
   }
-  return false;
+  if (node.type === 'ConditionalExpression') {
+    const consequentChanged = renameStaticValue(node.consequent, renames);
+    const alternateChanged = renameStaticValue(node.alternate, renames);
+    return consequentChanged || alternateChanged;
+  }
+  if (
+    (node.type !== 'StringLiteral' && node.type !== 'Literal') ||
+    typeof node.value !== 'string'
+  ) {
+    return false;
+  }
+  const replacement = renames.get(node.value);
+  if (!replacement) return false;
+  node.value = replacement;
+  if (node.raw) node.raw = undefined;
+  return true;
 }
 
 /**
@@ -96,158 +91,25 @@ export default function transformer(file, api) {
   const root = j(file.source);
   let hasChanges = false;
 
-  /**
-   * Rename a string literal value if it matches our renames.
-   * Unwraps TSAsExpression (e.g. 'positive' as const) to reach the literal.
-   * @returns {boolean} whether a rename occurred
-   */
-  function renameValue(/** @type {any} */ node, {precise = false} = {}) {
-    if (!node) return false;
-
-    // Unwrap TSAsExpression (e.g. 'positive' as const → StringLiteral)
-    const target = node.type === 'TSAsExpression' ? node.expression : node;
-
-    const isString =
-      target.type === 'StringLiteral' || target.type === 'Literal';
-    if (!isString || typeof target.value !== 'string') return false;
-
-    const replacement = RENAMES.get(target.value);
-    if (!replacement) return false;
-
-    // Ambiguous values (e.g. `info`) are only renamed in a precise context
-    // where the target component is known (a direct JSX attribute on a target).
-    // In context-blind paths they may belong to a component that legitimately
-    // keeps the value (e.g. Badge's `info`), so leave them untouched.
-    if (!precise && AMBIGUOUS_VALUES.has(target.value)) return false;
-
-    target.value = replacement;
-    if (target.raw) target.raw = undefined;
-    return true;
-  }
-
-  /**
-   * Rename elements in an array (handles TSAsExpression wrapping).
-   */
-  function renameArrayElements(/** @type {any} */ node, {precise = false} = {}) {
-    let arrayNode = node;
-    if (arrayNode.type === 'TSAsExpression') arrayNode = arrayNode.expression;
-    if (arrayNode.type !== 'ArrayExpression') return;
-    arrayNode.elements.forEach((/** @type {any} */ el) => {
-      if (renameValue(el, {precise})) hasChanges = true;
-    });
-  }
-
-  // Determine early: does this file import any target component?
-  const importsTarget = [...TARGET_COMPONENTS].some(
-    (name) =>
-      root.find(j.ImportSpecifier, {imported: {name}}).length > 0,
+  transformProp(
+    root,
+    j,
+    {
+      matchesImport: source => CORE_IMPORT_RE.test(source),
+      components: COMPONENT_PROPS,
+      normalizeComponentName: canonicalComponentName,
+    },
+    (propPath, {component}) => {
+      const prop = propPath.node;
+      const value =
+        prop.value?.type === 'JSXExpressionContainer'
+          ? prop.value.expression
+          : prop.value;
+      const renames = component === 'Badge' ? BADGE_RENAMES : STATUS_RENAMES;
+      if (renameStaticValue(value, renames)) hasChanges = true;
+    },
   );
 
-  // 1. JSX attributes on target components
-  root.find(j.JSXOpeningElement).forEach((/** @type {any} */ path) => {
-    const name = path.node.name;
-    const componentName = name.type === 'JSXIdentifier' ? name.name : null;
-    if (!componentName) return;
-
-    const isDirectTarget = TARGET_COMPONENTS.has(componentName);
-    // For non-target components, only check suffixed props if file imports targets
-    if (!isDirectTarget && !importsTarget) return;
-
-    path.node.attributes.forEach((/** @type {any} */ attr) => {
-      if (attr.type !== 'JSXAttribute') return;
-      const attrName = attr.name.name;
-
-      if (isDirectTarget) {
-        // Direct targets: only their specific props
-        const targetProps = COMPONENT_PROPS.get(componentName);
-        if (!targetProps || !targetProps.has(attrName)) return;
-      } else {
-        // Non-target components: suffixed prop names only
-        // (e.g. dotVariant on ChangelogSection wrapping XDSStatusDot)
-        if (!matchesPropName(attrName) || TARGET_PROP_NAMES.has(attrName)) return;
-      }
-
-      // Only a direct JSX attribute on a target component is a precise context
-      // where the component (and thus the validity of `info`) is known. The
-      // wrapper/suffixed-prop case is a heuristic and must not touch ambiguous
-      // values.
-      const precise = isDirectTarget;
-      const value = attr.value;
-
-      // variant="positive" (string literal)
-      if (renameValue(value, {precise})) {
-        hasChanges = true;
-        return;
-      }
-
-      // variant={'positive'} (expression container)
-      if (
-        value &&
-        value.type === 'JSXExpressionContainer' &&
-        value.expression
-      ) {
-        if (renameValue(value.expression, {precise})) {
-          hasChanges = true;
-          return;
-        }
-
-        // variant={condition ? 'positive' : 'negative'} (ternary)
-        if (value.expression.type === 'ConditionalExpression') {
-          if (renameValue(value.expression.consequent, {precise}))
-            hasChanges = true;
-          if (renameValue(value.expression.alternate, {precise}))
-            hasChanges = true;
-        }
-      }
-    });
-  });
-
-  // 2. Object properties in files importing target components.
-  //    Handles args objects, config objects, Storybook argTypes, etc.
-  if (importsTarget) {
-    const PropertyType = j.ObjectProperty ?? j.Property;
-    root.find(PropertyType).forEach((/** @type {any} */ path) => {
-      const key = path.node.key;
-      const keyName =
-        key.type === 'Identifier'
-          ? key.name
-          : key.type === 'StringLiteral' || key.type === 'Literal'
-            ? key.value
-            : null;
-
-      if (!keyName || !matchesPropName(keyName)) return;
-
-      const value = path.node.value;
-
-      // variant: 'positive' → variant: 'success'
-      if (renameValue(value)) {
-        hasChanges = true;
-        return;
-      }
-
-      // variant: { options: ['positive', 'negative', ...] }
-      if (value.type === 'ObjectExpression') {
-        const optionsProp = value.properties.find(
-          (/** @type {any} */ p) => p.key && (p.key.name === 'options' || p.key.value === 'options'),
-        );
-        if (optionsProp) {
-          renameArrayElements(optionsProp.value);
-        }
-      }
-
-      // variant: ['positive', 'negative'] or [...] as Type[]
-      renameArrayElements(value);
-    });
-  }
-
-  // 3. TypeScript type references: 'positive' | 'negative' in union types
-  if (importsTarget) {
-    root.find(j.TSLiteralType).forEach((/** @type {any} */ path) => {
-      const lit = path.node.literal;
-      if (renameValue(lit)) hasChanges = true;
-    });
-  }
-
   if (!hasChanges) return undefined;
   return root.toSource({quote: 'single'});
 }