Project Structure

Copy# yaml-language-server: $schema=https://raw.githubusercontent.com/ast-grep/ast-grep/main/schemas/project.json
 
ruleDirs:
  - .config/ast-grep/rules
testConfigs:
  - testDir: .config/ast-grep/rule-tests
utilDirs:
  - .config/ast-grep/rule-utils

CopyruleDirs:
  - .config/ast-grep/rules
testConfigs:
  - testDir: .config/ast-grep/rule-tests
utilDirs:
  - .config/ast-grep/rule-utils

Copy# yaml-language-server: $schema=https://raw.githubusercontent.com/ast-grep/ast-grep/main/schemas/project.json

Copyexport { ImportChain } from './import-chain'
export { RouteTypeahead } from './route-typeahead'
export { TreemapVisualizer } from './treemap-visualizer'
export { ErrorState } from './error-state'

Copyexport function SingleAnalyzer() {
  return (
    <AnalyzerBoundary defaultView={CompareView.Treemap}>
      <SingleAnalyzerController />
    </AnalyzerBoundary>
  )
}
 
function SingleAnalyzerController() {
  const model = useAnalyzerModel(false)
  return <SingleAnalyzerView model={model} />
}
 
export function CompareAnalyzer() {
  return (
    <AnalyzerBoundary defaultView={CompareView.Treemap}>
      <CompareAnalyzerController />
    </AnalyzerBoundary>
  )
}
 
function CompareAnalyzerController() {
  const model = useAnalyzerModel(true)
  return <CompareAnalyzerView model={model} />
}

Copyfunction useAnalyzerModel(compare: boolean) {
  // Read the URL before suspense data so static prerendering can bail out.
  useSearchParams()

Copyexport class ModulesData {
  private modulesHeader: ModulesDataHeader
  private modulesBinaryData: DataView
  private pathToModuleIndex: Map<string, ModuleIndex[]>
 
  constructor(modulesArrayBuffer: ArrayBuffer) {
    // Parse modules.data
    const modulesDataView = new DataView(modulesArrayBuffer)
    const modulesJsonLength = modulesDataView.getUint32(0, false)
    const modulesJsonBytes = new Uint8Array(
      modulesArrayBuffer,
      4,
      modulesJsonLength
    )
    const modulesJsonString = new TextDecoder('utf-8').decode(modulesJsonBytes)
    this.modulesHeader = JSON.parse(modulesJsonString) as ModulesDataHeader
    const modulesBinaryOffset = 4 + modulesJsonLength
    this.modulesBinaryData = new DataView(
      modulesArrayBuffer,
      modulesBinaryOffset
    )
 
    // Build pathToModuleIndex map
    this.pathToModuleIndex = new Map()
    for (let i = 0; i < this.modulesHeader.modules.length; i++) {
      const module = this.modulesHeader.modules[i]
      const existing = this.pathToModuleIndex.get(module.path)
      if (existing) {
        existing.push(i)
      } else {
        this.pathToModuleIndex.set(module.path, [i])
      }
    }
  }

Copyexport function assertMatchingModuleIndex(
  modules: ModulesData,
  route: AnalyzeData,
  side: string
): void {
  const moduleHash = modules.moduleIndexHash()
  const routeHash = route.moduleIndexHash()
  if (moduleHash !== routeHash) {
    throw new Error(`${side}: analyzer module-index fingerprint mismatch`)
  }
}

Copyexport class ModulesData {
  private modulesHeader: ModulesDataHeader
  private modulesBinaryData: DataView
  private pathToModuleIndex: Map<string, ModuleIndex[]>
 
  constructor(modulesArrayBuffer: ArrayBuffer) {
    // Parse modules.data
    const modulesDataView = new DataView(modulesArrayBuffer)
    const modulesJsonLength = modulesDataView.getUint32(0, false)
    const modulesJsonBytes = new Uint8Array(
      modulesArrayBuffer,
      4,
      modulesJsonLength
    )
    const modulesJsonString = new TextDecoder('utf-8').decode(modulesJsonBytes)
    this.modulesHeader = JSON.parse(modulesJsonString) as ModulesDataHeader
    const modulesBinaryOffset = 4 + modulesJsonLength
    this.modulesBinaryData = new DataView(
      modulesArrayBuffer,
      modulesBinaryOffset
    )
 
    // Build pathToModuleIndex map
    this.pathToModuleIndex = new Map()
    for (let i = 0; i < this.modulesHeader.modules.length; i++) {
      const module = this.modulesHeader.modules[i]
      const existing = this.pathToModuleIndex.get(module.path)
      if (existing) {
        existing.push(i)
      } else {
        this.pathToModuleIndex.set(module.path, [i])
      }
    }
  }
 
  moduleIndexHash(): string {
    const hash = this.modulesHeader.module_index_hash
    if (typeof hash !== 'string' || !hash) {
      throw new Error('Missing analyzer module-index fingerprint')
    }
    return hash
  }
 
  module(index: ModuleIndex): AnalyzeModule | undefined {
    return this.modulesHeader.modules[index]
  }
 
  moduleCount(): number {
    return this.modulesHeader.modules.length
  }
 
  getModuleIndiciesFromPath(path: string): ModuleIndex[] {
    return this.pathToModuleIndex.get(path) ?? []
  }
…
export interface FileNode {
  id: number
  name: string
  type: 'file'
  size: number
  outputType: 'code' | 'css' | 'asset'
  server: boolean
  client: boolean
  dependencies: number[]
  dependents: number[]
}
 
export interface DirectoryNode {
  id: number
  name: string
  type: 'directory'
  children: TreeNode[]
  size?: number
}

Copyconst moduleHash = modules.moduleIndexHash()
const routeHash = route.moduleIndexHash()
if (moduleHash !== routeHash) {
  throw new Error(`${side}: analyzer module-index fingerprint mismatch`)
}

Copyexport type LoaderTree = [
  segment: string,
  parallelRoutes: { [parallelRouterKey: string]: LoaderTree },
  modules: AppDirModules,
  staticSiblings: readonly string[] | null,
]

Copyexport async function getLayoutOrPageModule(loaderTree: LoaderTree) {
  const { layout, page, defaultPage } = loaderTree[2]
  const isLayout = typeof layout !== 'undefined'
  const isPage = typeof page !== 'undefined'
  const isDefaultPage =
    typeof defaultPage !== 'undefined' && loaderTree[0] === DEFAULT_SEGMENT_KEY
 
  let mod = undefined
  let modType: 'layout' | 'page' | undefined = undefined
  let filePath = undefined
 
  if (isLayout) {
    mod = await layout[0]()
    modType = 'layout'
    filePath = layout[1]
  } else if (isPage) {
    mod = await page[0]()
    modType = 'page'
    filePath = page[1]
  } else if (isDefaultPage) {
    mod = await defaultPage[0]()
    modType = 'page'
    filePath = defaultPage[1]
  }
 
  return { mod, modType, filePath }
}

Copyexport async function getComponentTypeModule(
  loaderTree: LoaderTree,
  moduleType: 'layout' | 'not-found' | 'forbidden' | 'unauthorized'
) {
  const { [moduleType]: module } = loaderTree[2]
  if (typeof module !== 'undefined') {
    return await module[0]()
  }
  return undefined
}

Copyexport * from './config-testing-utils'
export * from './middleware-testing-utils'
export { getRedirectUrl, getRewrittenUrl, isRewrite } from './utils'

Copy// the name of the export has to be the camelCase version of the file name (without the extension)
// TODO: remove this. We need it because using notFound from next/navigation imports this file :(
export * as appRouterContext from '../../../shared/lib/app-router-context.shared-runtime'

Copyexport interface MappedNftFileEntry {
  source: string
  destination: string
  hash?: string
  symlinkTarget?: string
  symlinkCrossesRoot: boolean
}

Copyasync function pushAsset(
  assets: Record<string, string>,
  assetsHashes: Record<string, string>,
  targetFilePath: string,
  sourceFilePath: string,
  bundler: Bundler,
  salt: string,
  hashOverride?: string
) {
  if (!(targetFilePath in assets)) {
    assets[targetFilePath] = sourceFilePath
    if (bundler === Bundler.Turbopack) {
      assetsHashes[targetFilePath] =
        hashOverride ?? (await hashFile(salt, sourceFilePath))
    }
  }
}
 
async function loadNFT(
  assets: Record<string, string>,
  assetsHashes: Record<string, string>,
  repoRoot: string,
  traceFilePath: string,
  syntheticSymlinks: SyntheticSymlinkManager,
  salt: string
): Promise<{ entryHash?: string }> {
  const nft = JSON.parse(await fs.readFile(traceFilePath, 'utf8')) as NftJson
 
  for (const entry of mapNftFileEntries(nft, traceFilePath, repoRoot)) {
    let source = entry.source
    let hash = entry.hash
 
    if (entry.symlinkCrossesRoot) {
      if (entry.symlinkTarget === undefined) {
        throw new InvariantError(
          `Expected cross-root symlink ${JSON.stringify(entry.destination)} to have a target`
        )
      }
      const linkTarget =
        path.relative(path.dirname(entry.destination), entry.symlinkTarget) ||
        '.'
      hash = hashLinkTarget(salt, linkTarget)
      source = syntheticSymlinks.createLink(entry.source, linkTarget, hash)
    }
 
    assets[entry.destination] = source
    if (hash) {
      assetsHashes[entry.destination] = hash
    }
  }
  return { entryHash: nft.entryHash }
}
 
async function hashFile(salt: string, filePath: string): Promise<string> {
  try {
    // Try symlink first, since readFile just transparently resolves those (or fails if it's a
    // directory symlink).
    const linkTarget = await fs.readlink(filePath)
    return hashLinkTarget(salt, linkTarget)
  } catch (e: any) {
    if (e.code === 'EINVAL') {
      // Not a symlink
      const hash = crypto.createHash('sha256')
      hash.update(salt)
      hash.update('file:')
      hash.update(await fs.readFile(filePath))
      return hash.digest('hex')
    } else {
      throw e
    }
  }
}
 
function hashLinkTarget(salt: string, linkTarget: string): string {
  const hash = crypto.createHash('sha256')
  hash.update(salt)
  hash.update('link')
  hash.update(linkTarget)
  return hash.digest('hex')

Copyexport function resolveNftOutputPath(
  outputRoot: string,
  destination: string
): string {
  const outputPath = path.resolve(outputRoot, destination)
  if (relativePathIfInside(outputRoot, outputPath) === undefined) {
    invalid(
      `output path ${JSON.stringify(destination)} escapes the deployment root`
    )
  }
  return outputPath
}

Copyexport type { SerializableTurborepoAccessTraceResult } from './types'
export {
  turborepoTraceAccess,
  writeTurborepoAccessTraceResult,
} from './helpers'
export { TurborepoAccessTraceResult } from './result'

Copyexport function dumpAnalyzeGraph(
  directory: string,
  snapshotName: string,
  routeFilter: string | undefined
): void {
  // Pipe stdout must block so writeSync supplies backpressure rather than EAGAIN.
  if (process.stdout._handle != null) {
    // @ts-ignore Node's internal handle, also used by the native bindings loader.
    process.stdout._handle.setBlocking?.(true)
  }

Copyexport * from './dev-overlay.browser'

Copyif (isPagesMounted) {
  // Switching between App and Pages Router is always a hard navigation
  // TODO: Support soft navigation between App and Pages Router
  throw new Error(
    'Next DevTools: Pages Dev Overlay is already mounted. This is a bug in Next.js'
  )
}
 

Copyexport const dispatcher: Dispatcher = {
  onBuildOk: createQueuable((dispatch: Dispatch) => {
    dispatch({ type: ACTION_BUILD_OK })
  }),
  onBuildError: createQueuable((dispatch: Dispatch, message: string) => {
    dispatch({ type: ACTION_BUILD_ERROR, message })
  }),
  onBeforeRefresh: createQueuable((dispatch: Dispatch) => {
    dispatch({ type: ACTION_BEFORE_REFRESH })
  }),
  onRefresh: createQueuable((dispatch: Dispatch) => {
    dispatch({ type: ACTION_REFRESH })
  }),

Copytype TrieNode<Value = string> = {
  value: Value | undefined
  children: {
    [key: string]: TrieNode<Value> | undefined
  }
}

Copyexport function SegmentStateProvider({ children }: { children: ReactNode }) {
  const [boundaryType, setBoundaryType] = useState<SegmentBoundaryType | null>(
    null
  )
 
  const [errorBoundaryKey, setErrorBoundaryKey] = useState(0)
  const reloadBoundary = useCallback(
    () => setErrorBoundaryKey((prev) => prev + 1),
    []
  )

Copy// Use `useLayoutEffect` to ensure the state is updated during suspense.
// `useEffect` won't work as the state is preserved during suspense.
useLayoutEffect(() => {
  dispatcher.segmentExplorerNodeAdd(nodeState)
  return () => {
    dispatcher.segmentExplorerNodeRemove(nodeState)
  }
}, [nodeState])

Copyexport { originConsoleError } from './intercept-console-error'
export { handleClientError } from './use-error-handler'
export { decorateDevError } from './stitched-error'

Copyexport function collectDocFiles(dir: string): { relativePath: string }[] {
  return (fs.readdirSync(dir, { recursive: true }) as string[])
    .filter(
      (f) =>
        (f.endsWith('.mdx') || f.endsWith('.md')) &&
        !/[/\\]index\.mdx$/.test(f) &&
        !/[/\\]index\.md$/.test(f) &&
        !f.startsWith('index.')
    )
    .sort()
    .map((f) => ({ relativePath: f.replace(/\\/g, '/') }))
}

Copyinterface DocSection {
  name: string
  files: { relativePath: string }[]
  subsections: DocSection[]
}

Copyreturn (fs.readdirSync(dir, { recursive: true }) as string[])
  .filter(
    (f) =>
      (f.endsWith('.mdx') || f.endsWith('.md')) &&
      !/[/\\]index\.mdx$/.test(f) &&
      !/[/\\]index\.md$/.test(f) &&
      !f.startsWith('index.')
  )

Copyfunction detectWorkspace(cwd: string): WorkspaceInfo {
  const packageJsonPath = path.join(cwd, 'package.json')
 
  // Check pnpm workspaces (pnpm-workspace.yaml)
  const pnpmWorkspacePath = path.join(cwd, 'pnpm-workspace.yaml')
  if (fs.existsSync(pnpmWorkspacePath)) {
    const packages = parsePnpmWorkspace(pnpmWorkspacePath)
    if (packages.length > 0) {
      return { isMonorepo: true, type: 'pnpm', packages }
    }
  }
 
  // Check npm/yarn workspaces (package.json workspaces field)
  if (fs.existsSync(packageJsonPath)) {
    const packages = parsePackageJsonWorkspaces(packageJsonPath)
    if (packages.length > 0) {
      return { isMonorepo: true, type: 'npm', packages }
    }
  }
 
  // Check Lerna (lerna.json)
  const lernaPath = path.join(cwd, 'lerna.json')
  if (fs.existsSync(lernaPath)) {
    const packages = parseLernaConfig(lernaPath)
    if (packages.length > 0) {
      return { isMonorepo: true, type: 'lerna', packages }

Copyexport function ensureGitignoreEntry(cwd: string): GitignoreStatus {
  const gitignorePath = path.join(cwd, '.gitignore')
  const entryRegex = /^\s*\.next-docs(?:\/.*)?$/
 
  let content = ''
  if (fs.existsSync(gitignorePath)) {
    content = fs.readFileSync(gitignorePath, 'utf-8')
  }
 
  const hasEntry = content.split(/\r?\n/).some((line) => entryRegex.test(line))
 
  if (hasEntry) {
    return { path: gitignorePath, updated: false, alreadyPresent: true }
  }
...