@astryxdesign/cli 0.2.0 → 0.3.0

package/assets/codemods/transforms/v0.1.0/migrate-xds-css-surfaces.mjs

@@ -0,0 +1,121 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Codemod: migrate XDS CSS surfaces to their Astryx equivalents
+ *
+ * The v0.1.0 release renamed the DOM namespace emitted by @astryxdesign/core
+ * from `xds-*` to `astryx-*` and dropped the dual-emit compatibility (core no
+ * longer emits the legacy `xds-*` classes or `data-xds-*` attributes). Any
+ * consumer CSS that targeted those surfaces is now broken.
+ *
+ * This transform performs precise, targeted string replacements on CSS/SCSS
+ * files for the documented surfaces only (selectors, layer names, and package
+ * stylesheet imports):
+ *
+ * - `.xds-*` class-name prefix in selectors (matched only after a `.` so it is
+ *   a class selector).
+ * - `[data-xds-theme`, `[data-xds-theme-prose`, `[data-xds-media` attribute
+ *   selectors.
+ * - `\@layer xds-theme` / `\@layer xds-base` cascade layer names, including
+ *   comma-separated `\@layer a, b;` statement lists and nested blocks.
+ * - `\@import '\@xds/...'` package stylesheet imports: scope rewrite, plus the
+ *   `\@xds/core/xds.css` -> `\@astryxdesign/core/astryx.css` file rename and the
+ *   `theme-daily` -> `theme-neutral` collapse.
+ *
+ * It deliberately does NOT blindly replace every `xds` substring: a bare
+ * `xds` in a comment, a custom-property value, or an unrelated identifier is
+ * left untouched. CSS has no meaningful AST for this class of edit, so this is
+ * a plain string transform — `api.jscodeshift` is available but unused.
+ */
+
+export const meta = {
+  title: 'Migrate .xds-* / [data-xds-*] / @layer xds-* CSS surfaces to astryx',
+  description:
+    'Rewrites the documented XDS CSS surfaces to their Astryx equivalents: ' +
+    'the `.xds-*` class-selector prefix, `[data-xds-theme]` / ' +
+    '`[data-xds-theme-prose]` / `[data-xds-media]` attribute selectors, ' +
+    '`@layer xds-theme` / `@layer xds-base` cascade-layer names, and ' +
+    '`@import` of @xds/* package stylesheets (scope rewrite, xds.css->astryx.css, ' +
+    'theme-daily->theme-neutral) all become their Astryx forms.',
+  pr: '#3092',
+  fileExtensions: ['.css', '.scss'],
+};
+
+// The XDS cascade-layer names we own. A `@layer` prelude can name several
+// layers in a comma-separated list (`@layer a, b;`), so we can't anchor every
+// occurrence to the `@layer` keyword. We instead rewrite these exact layer
+// tokens within a `@layer ...` prelude (up to the next `{` or `;`).
+const XDS_LAYER_NAMES = new Map([
+  ['xds-theme', 'astryx-theme'],
+  ['xds-base', 'astryx-base'],
+]);
+
+function rewriteLayerPrelude(/** @type {any} */ prelude) {
+  return prelude.replace(/\bxds-(?:theme|base)\b/g, (/** @type {any} */ name) =>
+    XDS_LAYER_NAMES.get(name) ?? name,
+  );
+}
+
+// Rewrite a single @import package-stylesheet specifier value (without quotes)
+// from an @xds/* path to its @astryxdesign/* equivalent. Handles the two
+// non-mechanical cases beyond the scope swap:
+//   @xds/core/xds.css            -> @astryxdesign/core/astryx.css   (file rename)
+//   @xds/theme-daily/*           -> @astryxdesign/theme-neutral/*   (collapse)
+// Returns the original value unchanged if it is not an @xds/* specifier.
+function rewriteImportSpecifier(/** @type {any} */ spec) {
+  if (!spec.startsWith('@xds/')) return spec;
+  // Theme package collapse (daily -> neutral).
+  let next = spec.replace(
+    /^@xds\/theme-daily(\/|$)/,
+    '@astryxdesign/theme-neutral$1',
+  );
+  if (next === spec) {
+    // Not a collapsed theme — plain scope swap.
+    next = spec.replace(/^@xds\//, '@astryxdesign/');
+  }
+  // Core stylesheet file rename: xds.css -> astryx.css (only the core bundle;
+  // reset.css and others keep their names).
+  next = next.replace(
+    /^@astryxdesign\/core\/xds\.css$/,
+    '@astryxdesign/core/astryx.css',
+  );
+  return next;
+}
+
+// Ordered, non-overlapping replacements. Each pattern is intentionally narrow
+// so we never touch a bare `xds` substring outside these surfaces.
+/** @type {Array<{re: RegExp, to: any}>} */
+const REPLACEMENTS = [
+  // Class-name prefix: only when preceded by a `.` (a class selector).
+  {re: /\.xds-/g, to: '.astryx-'},
+  // Attribute selectors: any `[data-xds-` opener (theme, theme-prose, media).
+  {re: /\[data-xds-/g, to: '[data-astryx-'},
+  // Cascade-layer preludes: `@layer <names>` up to the block `{` or `;`.
+  // Rewrite only the recognized xds-* layer tokens inside the prelude.
+  {re: /@layer\b[^{;]*/g, to: (/** @type {any} */ match) => rewriteLayerPrelude(match)},
+  // Package stylesheet imports: `@import '@xds/...'` or `@import url('@xds/...')`.
+  // Rewrite only the quoted @xds/* specifier, preserving the quote style.
+  {
+    re: /@import\s+(?:url\(\s*)?(['"])(@xds\/[^'"]+)\1/g,
+    to: (/** @type {any} */ match, /** @type {any} */ quote, /** @type {any} */ spec) => {
+      const next = rewriteImportSpecifier(spec);
+      return next === spec ? match : match.replace(spec, next);
+    },
+  },
+];
+
+/**
+ * @param {import('../../../../authoring/codemod/type').AstryxCodemodFile} file
+ * @returns {string | null | undefined}
+ */
+export default function transformer(file /*, api */) {
+  const source = file.source;
+  if (typeof source !== 'string') return undefined;
+
+  let next = source;
+  for (const {re, to} of REPLACEMENTS) {
+    next = next.replace(re, to);
+  }
+
+  return next === source ? undefined : next;
+}

package/assets/codemods/transforms/v0.1.0/migrate-xds-declare-module.mjs

@@ -0,0 +1,82 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Codemod: migrate `declare module "@xds/..."` augmentations to
+ * `@astryxdesign/...`
+ *
+ * The v0.1.0 release moved the public package scope from @xds to
+ * @astryxdesign. TypeScript module augmentations (`declare module "@xds/core"
+ * { ... }`) reference the package by its string specifier, so they are dead
+ * after the scope rename: TypeScript resolves the augmentation against a
+ * module that no longer exists.
+ *
+ * This transform rewrites the augmented module string on `TSModuleDeclaration`
+ * nodes whose `id` is a StringLiteral matching a renamed @xds package (or one
+ * of its subpaths). It only touches the module path — identifiers *inside* the
+ * augmentation (e.g. an augmented interface name) are a separate concern
+ * handled by drop-xds-prefix-imports.
+ *
+ * Ordered AFTER migrate-xds-module-specifiers in the v0.1.0 manifest: it uses
+ * the same PACKAGE_RENAMES mapping and cleans up the module-augmentation
+ * surface alongside the import/export/require specifier rename.
+ */
+
+export const meta = {
+  title: 'Migrate declare-module augmentations from @xds/* to @astryxdesign/*',
+  description:
+    'Rewrites the module specifier on TypeScript `declare module "@xds/..."` ' +
+    'augmentations to the @astryxdesign/* packages used by Astryx v0.1.0. ' +
+    'Only the augmented module path is changed; identifiers inside the ' +
+    'augmentation are left untouched.',
+  pr: '#3092',
+  fileExtensions: ['.ts', '.d.ts', '.tsx'],
+};
+
+const PACKAGE_RENAMES = new Map([
+  ['@xds/build', '@astryxdesign/build'],
+  ['@xds/cli', '@astryxdesign/cli'],
+  ['@xds/core', '@astryxdesign/core'],
+  ['@xds/lab', '@astryxdesign/lab'],
+  ['@xds/theme-butter', '@astryxdesign/theme-butter'],
+  ['@xds/theme-chocolate', '@astryxdesign/theme-chocolate'],
+  ['@xds/theme-daily', '@astryxdesign/theme-neutral'],
+  ['@xds/theme-gothic', '@astryxdesign/theme-gothic'],
+  ['@xds/theme-matcha', '@astryxdesign/theme-matcha'],
+  ['@xds/theme-neutral', '@astryxdesign/theme-neutral'],
+  ['@xds/theme-stone', '@astryxdesign/theme-stone'],
+  ['@xds/theme-y2k', '@astryxdesign/theme-y2k'],
+]);
+
+function renamePackageSpecifier(/** @type {any} */ value) {
+  if (typeof value !== 'string') return value;
+  for (const [from, to] of PACKAGE_RENAMES) {
+    if (value === from) return to;
+    if (value.startsWith(from + '/')) return to + value.slice(from.length);
+  }
+  return value;
+}
+
+/**
+ * @param {import('../../../../authoring/codemod/type').AstryxCodemodFile} file
+ * @param {import('../../../../authoring/codemod/type').CodemodTransformApi} api
+ * @returns {string | null | undefined}
+ */
+export default function transformer(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let hasChanges = false;
+
+  root.find(j.TSModuleDeclaration).forEach((/** @type {any} */ path) => {
+    const id = path.node.id;
+    // Module augmentations name the module with a string literal id; a
+    // `namespace Foo {}` uses an Identifier id, which we ignore.
+    if (!id || (id.type !== 'StringLiteral' && id.type !== 'Literal')) return;
+    if (typeof id.value !== 'string') return;
+    const next = renamePackageSpecifier(id.value);
+    if (next === id.value) return;
+    id.value = next;
+    hasChanges = true;
+  });
+
+  return hasChanges ? root.toSource() : undefined;
+}

package/assets/codemods/transforms/v0.1.0/migrate-xds-module-specifiers.mjs

@@ -0,0 +1,196 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Codemod: migrate module specifiers from @xds/* to @astryxdesign/*
+ *
+ * The v0.1.0 release moved the public package scope from @xds to
+ * @astryxdesign. Consumers update dependencies first, install, then run
+ * `astryx upgrade`; this transform only updates JS/TS module specifiers in
+ * source code.
+ */
+
+export const meta = {
+  title: 'Migrate module specifiers from @xds/* to @astryxdesign/*',
+  description:
+    'Updates JS/TS import, export, dynamic import, require, TS import-type, ' +
+    'and test-framework mock (vi.mock / jest.mock) module specifiers from ' +
+    '@xds/* to the @astryxdesign/* packages used by Astryx v0.1.0.',
+  pr: '#3092',
+  fileExtensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs'],
+};
+
+const PACKAGE_RENAMES = new Map([
+  ['@xds/build', '@astryxdesign/build'],
+  ['@xds/cli', '@astryxdesign/cli'],
+  ['@xds/core', '@astryxdesign/core'],
+  ['@xds/lab', '@astryxdesign/lab'],
+  ['@xds/theme-butter', '@astryxdesign/theme-butter'],
+  ['@xds/theme-chocolate', '@astryxdesign/theme-chocolate'],
+  ['@xds/theme-daily', '@astryxdesign/theme-neutral'],
+  ['@xds/theme-gothic', '@astryxdesign/theme-gothic'],
+  ['@xds/theme-matcha', '@astryxdesign/theme-matcha'],
+  ['@xds/theme-neutral', '@astryxdesign/theme-neutral'],
+  ['@xds/theme-stone', '@astryxdesign/theme-stone'],
+  ['@xds/theme-y2k', '@astryxdesign/theme-y2k'],
+]);
+
+function renamePackageSpecifier(/** @type {any} */ value) {
+  if (typeof value !== 'string') return value;
+  for (const [from, to] of PACKAGE_RENAMES) {
+    if (value === from) return to;
+    if (value.startsWith(from + '/')) return to + value.slice(from.length);
+  }
+  return value;
+}
+
+function rewriteLiteral(/** @type {any} */ node) {
+  if (!node || typeof node.value !== 'string') return false;
+  const next = renamePackageSpecifier(node.value);
+  if (next === node.value) return false;
+  node.value = next;
+  return true;
+}
+
+// @xds/theme-daily collapses to @astryxdesign/theme-neutral, whose exported
+// theme binding is `neutralTheme` (not `defaultTheme`). When we rewrite an
+// import from that package, remap a `defaultTheme` named import to
+// `neutralTheme`, aliasing back to the original local name so downstream usages
+// keep working unchanged:
+//   import {defaultTheme} from '@xds/theme-daily'
+//     -> import {neutralTheme as defaultTheme} from '@astryxdesign/theme-neutral'
+// An already-aliased `{defaultTheme as x}` just has its imported name remapped.
+const THEME_EXPORT_RENAMES = new Map([['defaultTheme', 'neutralTheme']]);
+const COLLAPSED_THEME_SOURCES = new Set(['@xds/theme-daily']);
+
+function isCollapsedThemeSource(/** @type {any} */ value) {
+  if (typeof value !== 'string') return false;
+  for (const src of COLLAPSED_THEME_SOURCES) {
+    if (value === src || value.startsWith(src + '/')) return true;
+  }
+  return false;
+}
+
+// Test-framework mock calls take the mocked module path as their first
+// argument (`vi.mock('@xds/core/Text', factory)`). That path is a plain string
+// literal -- not an ImportDeclaration source -- so it slips past the import/
+// export handlers and, left unrewritten, the mock would target the stale
+// `@xds/*` path and stop intercepting the renamed `@astryxdesign/*` import.
+// Recognized callees: `vi.mock`, `vi.doMock`, `jest.mock`, `jest.doMock`, and
+// a bare `mock(...)` (destructured from the test runner).
+const MOCK_METHOD_NAMES = new Set(['mock', 'doMock']);
+const MOCK_OBJECT_NAMES = new Set(['vi', 'jest']);
+
+function isMockCall(/** @type {any} */ callee) {
+  if (
+    callee.type === 'MemberExpression' &&
+    !callee.computed &&
+    callee.object.type === 'Identifier' &&
+    MOCK_OBJECT_NAMES.has(callee.object.name) &&
+    callee.property.type === 'Identifier' &&
+    MOCK_METHOD_NAMES.has(callee.property.name)
+  ) {
+    return true;
+  }
+  return callee.type === 'Identifier' && callee.name === 'mock';
+}
+
+function remapThemeExportNames(/** @type {any} */ importPath, /** @type {any} */ j) {
+  let changed = false;
+  importPath.node.specifiers = (importPath.node.specifiers || []).map((/** @type {any} */ spec) => {
+    if (spec.type !== 'ImportSpecifier') return spec;
+    const importedName = spec.imported.name;
+    const renamed = THEME_EXPORT_RENAMES.get(importedName);
+    if (!renamed) return spec;
+    // Preserve the original local binding (so downstream usages keep working),
+    // remapping only the imported name. Build a FRESH specifier node: recast
+    // preserves the printed form of a mutated ImportSpecifier and would drop a
+    // newly-introduced `as local` alias, so mutating in place loses it.
+    const localName = spec.local.name;
+    changed = true;
+    return j.importSpecifier(j.identifier(renamed), j.identifier(localName));
+  });
+  return changed;
+}
+
+/**
+ * @param {import('../../../../authoring/codemod/type').AstryxCodemodFile} file
+ * @param {import('../../../../authoring/codemod/type').CodemodTransformApi} api
+ * @returns {string | null | undefined}
+ */
+export default function transformer(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let hasChanges = false;
+
+  root.find(j.ImportDeclaration).forEach((/** @type {any} */ path) => {
+    // Remap collapsed-theme export names BEFORE rewriting the source specifier
+    // (the check keys off the original @xds/theme-daily path).
+    if (isCollapsedThemeSource(path.node.source.value)) {
+      hasChanges = remapThemeExportNames(path, j) || hasChanges;
+    }
+    hasChanges = rewriteLiteral(path.node.source) || hasChanges;
+  });
+
+  root.find(j.ExportNamedDeclaration).forEach((/** @type {any} */ path) => {
+    hasChanges = rewriteLiteral(path.node.source) || hasChanges;
+  });
+
+  root.find(j.ExportAllDeclaration).forEach((/** @type {any} */ path) => {
+    hasChanges = rewriteLiteral(path.node.source) || hasChanges;
+  });
+
+  root.find(j.CallExpression).forEach((/** @type {any} */ path) => {
+    const isDynamicImport = path.node.callee.type === 'Import';
+    const isRequire =
+      path.node.callee.type === 'Identifier' &&
+      path.node.callee.name === 'require';
+    if (isDynamicImport || isRequire || isMockCall(path.node.callee)) {
+      const [arg] = path.node.arguments;
+      if (arg?.type === 'StringLiteral' || arg?.type === 'Literal') {
+        hasChanges = rewriteLiteral(arg) || hasChanges;
+      }
+    }
+  });
+
+  // TS `import(...)` TYPE specifiers -- e.g. the `import('@xds/core/Text')` in
+  // `typeof import('@xds/core/Text')` -- parse to a `TSImportType` node, not a
+  // dynamic-import CallExpression, so the handler above never reaches them.
+  // ast-types' traversal also doesn't descend into a `TSImportType` nested in a
+  // generic type-argument position (e.g. `orig<typeof import('@xds/core/Text')>()`),
+  // so `j.find(j.TSImportType)` misses it. Walk the raw AST to cover every
+  // position. Re-visiting a node the loop above handled is harmless: the
+  // literal is already rewritten, so the second pass is a no-op.
+  const seenTypeImportNodes = new Set();
+  const rewriteTSImportTypes = (/** @type {any} */ node) => {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) {
+      for (const child of node) rewriteTSImportTypes(child);
+      return;
+    }
+    if (seenTypeImportNodes.has(node)) return;
+    seenTypeImportNodes.add(node);
+
+    if (node.type === 'TSImportType' && node.argument) {
+      hasChanges = rewriteLiteral(node.argument) || hasChanges;
+    }
+
+    for (const key of Object.keys(node)) {
+      if (
+        key === 'loc' ||
+        key === 'start' ||
+        key === 'end' ||
+        key === 'range' ||
+        key === 'comments' ||
+        key === 'leadingComments' ||
+        key === 'trailingComments' ||
+        key === 'tokens'
+      ) {
+        continue;
+      }
+      rewriteTSImportTypes(node[key]);
+    }
+  };
+  rewriteTSImportTypes(root.get().node);
+
+  return hasChanges ? root.toSource() : undefined;
+}

package/assets/codemods/transforms/v0.1.2/rename-text-color-active-to-accent.mjs

@@ -0,0 +1,142 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file Codemod: Rename Text/Heading/Link/Timestamp color "active" to "accent"
+ * @see https://github.com/facebook/astryx/issues/2863
+ *
+ * The `active` text-color value is renamed to `accent` and now maps to the
+ * dedicated `--color-text-accent` token (legible accent ink) instead of
+ * `--color-accent` (the interactive/base accent surface). This gives a
+ * first-class, type-safe way to render accent-colored text and resolves the
+ * gap reported in #2863.
+ *
+ * Transforms (scoped to Text, Heading, Link, and Timestamp):
+ * - <Text color="active" />            → <Text color="accent" />
+ * - <Heading color={'active'} />       → <Heading color={'accent'} />
+ * - <Text color={cond ? 'active' : x}> → <Text color={cond ? 'accent' : x}>
+ * - Storybook argTypes: color: { options: [..., 'active', ...] }
+ *     → replaces 'active' with 'accent' (files importing a target component)
+ * - Object properties: { color: 'active' } / { color: 'active' as const }
+ *     → { color: 'accent' } (files importing a target component)
+ *
+ * The transform deliberately does NOT touch bare `'active'` strings that are
+ * not a `color` value (e.g. status enums, ids, filter values), so it is safe
+ * to run across an entire codebase.
+ */
+
+export const meta = {
+  title: 'Rename Text/Heading/Link/Timestamp color "active" to "accent"',
+  description:
+    'Renames the `color="active"` value to `color="accent"` on Text, Heading, ' +
+    'Link, and Timestamp. The `accent` value maps to `--color-text-accent` ' +
+    '(the dedicated accent text ink). Also updates Storybook color argTypes ' +
+    'options and object-literal `color` props in files that import a target component.',
+  pr: '#2863',
+};
+
+const OLD_VALUE = 'active';
+const NEW_VALUE = 'accent';
+
+/** Components whose `color` prop accepts a TextColor value. */
+const TARGET_COMPONENTS = new Set(['Text', 'Heading', 'Link', 'Timestamp']);
+
+/**
+ * @param {import('../../../../authoring/codemod/type').AstryxCodemodFile} file
+ * @param {import('../../../../authoring/codemod/type').CodemodTransformApi} api
+ * @returns {string | null | undefined}
+ */
+export default function transformer(file, api) {
+  const j = api.jscodeshift;
+  const root = j(file.source);
+  let hasChanges = false;
+
+  /** Rewrite a string-literal node when it equals the old value. */
+  function renameStringLiteral(/** @type {any} */ node) {
+    if (!node) return false;
+    if (
+      (node.type === 'StringLiteral' || node.type === 'Literal') &&
+      node.value === OLD_VALUE
+    ) {
+      node.value = NEW_VALUE;
+      if (node.raw) node.raw = `'${NEW_VALUE}'`;
+      return true;
+    }
+    return false;
+  }
+
+  /** Recursively rewrite the old value inside ternary/logical expressions. */
+  /** @returns {boolean} */
+  function renameInExpression(/** @type {any} */ node) {
+    if (!node) return false;
+    let changed = false;
+    if (node.type === 'StringLiteral' || node.type === 'Literal') {
+      changed = renameStringLiteral(node) || changed;
+    } else if (node.type === 'ConditionalExpression') {
+      changed = renameInExpression(node.consequent) || changed;
+      changed = renameInExpression(node.alternate) || changed;
+    } else if (node.type === 'LogicalExpression') {
+      changed = renameInExpression(node.left) || changed;
+      changed = renameInExpression(node.right) || changed;
+    } else if (node.type === 'TSAsExpression') {
+      // `'active' as const` → rewrite the inner expression
+      changed = renameInExpression(node.expression) || changed;
+    }
+    return changed;
+  }
+
+  // --- 1. JSX attribute: color="active" / color={'active'} 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 || !TARGET_COMPONENTS.has(componentName)) return;
+
+    path.node.attributes.forEach((/** @type {any} */ attr) => {
+      if (attr.type !== 'JSXAttribute') return;
+      if (!attr.name || attr.name.name !== 'color') return;
+
+      const value = attr.value;
+      if (!value) return;
+
+      if (value.type === 'StringLiteral' || value.type === 'Literal') {
+        if (renameStringLiteral(value)) hasChanges = true;
+      } else if (value.type === 'JSXExpressionContainer') {
+        if (renameInExpression(value.expression)) hasChanges = true;
+      }
+    });
+  });
+
+  // Object-property / argTypes transforms only run in files that use a target
+  // component — keeps unrelated `{ color: 'active' }` / `'active'` strings safe.
+  const importsTarget =
+    root
+      .find(j.ImportSpecifier)
+      .filter((/** @type {any} */ p) => TARGET_COMPONENTS.has(p.node.imported?.name))
+      .size() > 0;
+
+  if (importsTarget) {
+    const PropertyType = j.ObjectProperty ?? j.Property;
+
+    // --- 2. Object property: { color: 'active' } / { color: 'active' as const } ---
+    root.find(PropertyType, {key: {name: 'color'}}).forEach((/** @type {any} */ path) => {
+      if (renameInExpression(path.node.value)) hasChanges = true;
+    });
+
+    // --- 3. Storybook argTypes: color: { options: [..., 'active', ...] } ---
+    root.find(PropertyType, {key: {name: 'color'}}).forEach((/** @type {any} */ path) => {
+      const value = path.node.value;
+      if (!value || value.type !== 'ObjectExpression') return;
+
+      const optionsProp = value.properties.find(
+        (/** @type {any} */ p) => p.key && (p.key.name === 'options' || p.key.value === 'options'),
+      );
+      if (optionsProp && optionsProp.value.type === 'ArrayExpression') {
+        optionsProp.value.elements.forEach((/** @type {any} */ el) => {
+          if (renameStringLiteral(el)) hasChanges = true;
+        });
+      }
+    });
+  }
+
+  if (!hasChanges) return undefined;
+  return root.toSource({quote: 'single'});
+}