Function transformer

packages/next-codemod/transforms/remove-unstable-prefix.ts:16–357

(
  file: FileInfo,
  _api: API,
  options: Options
)

}

export default function transformer(
  file: FileInfo,
  _api: API,
  options: Options
) {
  const j = createParserFromPath(file.path)
  const root = j(file.source)
  let hasChanges = false

  try {
    // Track identifier renames that need to be applied
    const identifierRenames: Array<{ oldName: string; newName: string }> = []
    // Track variables assigned from next/cache imports/requires
    const cacheVariables = new Set<string>()

    // Handle ES6 imports: import { unstable_cacheTag } from 'next/cache'
    root
      .find(j.ImportDeclaration, { source: { value: 'next/cache' } })
      .forEach((path) => {
        path.node.specifiers?.forEach((specifier) => {
          if (
            specifier.type === 'ImportSpecifier' &&
            specifier.imported?.type === 'Identifier' &&
            shouldRenameProperty(specifier.imported.name)
          ) {
            const oldName = specifier.imported.name
            const newName = UNSTABLE_TO_STABLE_MAPPING[oldName]

            // Handle alias scenarios
            if (specifier.local && specifier.local.name === newName) {
              // Same alias name: { unstable_cacheTag as cacheTag } -> { cacheTag }
              const newSpecifier = j.importSpecifier(j.identifier(newName))
              const specifierIndex = path.node.specifiers.indexOf(specifier)
              path.node.specifiers[specifierIndex] = newSpecifier
              identifierRenames.push({ oldName, newName })
            } else {
              // Normal case: just update the imported name
              specifier.imported = j.identifier(newName)
              if (!specifier.local || specifier.local.name === oldName) {
                // Not aliased or aliased with old name: add to identifier renames
                identifierRenames.push({ oldName, newName })
              }
            }

            hasChanges = true
          } else if (specifier.type === 'ImportNamespaceSpecifier') {
            // Handle namespace imports: import * as cache from 'next/cache'
            cacheVariables.add(specifier.local.name)
          }
        })
      })

    // Handle export statements: export { unstable_cacheTag } from 'next/cache'
    root
      .find(j.ExportNamedDeclaration, { source: { value: 'next/cache' } })
      .forEach((path) => {
        path.node.specifiers?.forEach((specifier) => {
          if (