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

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

@@ -1,126 +1,205 @@
 // Copyright (c) Meta Platforms, Inc. and affiliates.
 
-import {describe, expect, it} from 'vitest';
-import transform from '../rename-status-variants.mjs';
+import {describe, it, expect} from 'vitest';
 
 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: () => {}};
-  return transform({source, path: 'test.tsx'}, api) ?? source;
+  const file = {source, path: 'test.tsx'};
+  const result = transform(file, api);
+  return result ?? source;
 }
 
 describe('rename-status-variants', () => {
-  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'} />;`);
-
-    expect(output).toContain("variant='success'");
-    expect(output).toContain("variant={'error'}");
-    expect(output).toContain("ready ? 'accent' : 'success'");
+  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 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} />;`);
-
-    expect(output).toContain("{'success' satisfies StatusDotVariant}");
+  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'");
   });
 
-  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" />
-</>;`);
-
-    expect(output.match(/'error'/g)).toHaveLength(2);
-    expect(output.match(/'success'/g)).toHaveLength(2);
+  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('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 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("<Dot variant='success'");
-    expect(output).toContain("<IconGlyph color='error'");
+  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('maps namespace imports', async () => {
-    const output = await applyTransform(`import * as Core from '@astryxdesign/core';
-const view = <Core.StatusDot variant="info" />;`);
+  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).toContain("variant='accent'");
+  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('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 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('variant="info"');
-    expect(output).toContain("variant='success'");
-    expect(output).toContain("variant='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('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()} />;`;
+  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(await applyTransform(input)).toBe(input);
+  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('leaves unrelated props untouched', async () => {
-    const output = await applyTransform(`import {StatusDot} from '@astryxdesign/core';
-const view = <StatusDot variant="positive" label="positive" />;`);
+  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='success'");
-    expect(output).toContain('label="positive"');
+  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('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 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('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" />; }`);
+  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"');
+  });
 
-    expect(output).toContain("variant='success'");
-    expect(output).toContain('variant="negative"');
+  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('returns undefined when no direct prop needs a change', async () => {
+  it('returns undefined when no changes needed', async () => {
+    const {default: transform} = await import(
+      '../rename-status-variants.mjs'
+    );
     const jscodeshift = (await import('jscodeshift')).default;
     const j = jscodeshift.withParser('tsx');
-    const source = `import {StatusDot} from '@astryxdesign/core';
-const view = <StatusDot variant="success" />;`;
-    expect(
-      transform(
-        {source, path: 'test.tsx'},
-        {jscodeshift: j, stats: () => {}, report: () => {}},
-      ),
-    ).toBeUndefined();
+    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'");
   });
 });

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

@@ -4,81 +4,86 @@
  * @file Codemod: Rename status variants positive/negative → success/error
  * @see https://github.com/facebookexperimental/xds/issues/996
  *
- * 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.
+ * 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.
  */
 
-import {transformProp} from '../../transform-prop.mjs';
-
 export const meta = {
   title: 'Rename status variants positive/negative → success/error',
   description:
-    '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.',
+    '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.',
   pr: '#996',
 };
 
-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([
+/** Rename mappings. */
+const RENAMES = new Map([
   ['positive', 'success'],
   ['negative', 'error'],
   ['info', 'accent'],
 ]);
 
-const BADGE_RENAMES = new Map([
-  ['positive', 'success'],
-  ['negative', 'error'],
+/**
+ * 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'])],
 ]);
 
-/** @param {string} name */
-function canonicalComponentName(name) {
-  return name.startsWith('XDS') ? name.slice(3) : name;
+/** 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 {any} node
- * @param {ReadonlyMap<string, string>} renames
- * @returns {boolean}
+ * Check if a key matches a target prop — exact or case-insensitive suffix.
+ * e.g. "dotVariant" matches because it ends with "variant".
  */
-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);
+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;
   }
-  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;
+  return false;
 }
 
 /**
@@ -91,25 +96,158 @@ export default function transformer(file, api) {
   const root = j(file.source);
   let hasChanges = false;
 
-  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;
-    },
+  /**
+   * 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,
   );
 
+  // 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'});
 }