walkImplementation() — tailwindcss Function Reference

Architecture documentation for the walkImplementation() function in walk.ts from the tailwindcss codebase.

Function typescript OxideCore PreProcessors called by 1

Entity Profile

OxideCore→ PreProcessors→ walkImplementation() — tailwindcss Function Reference

Dependency Diagram

graph TD
  40dc6849_4404_c0e6_ed53_be2feaa7fa1c["walkImplementation()"]
  a32bba76_f60d_883f_1ff1_276a0bb9db9f["walk()"]
  a32bba76_f60d_883f_1ff1_276a0bb9db9f -->|calls| 40dc6849_4404_c0e6_ed53_be2feaa7fa1c
  style 40dc6849_4404_c0e6_ed53_be2feaa7fa1c fill:#6366f1,stroke:#818cf8,color:#fff

Relationship Graph

Source Code

packages/tailwindcss/src/walk.ts lines 60–196

function walkImplementation<T extends { nodes?: T[] }>(
  ast: T[],
  enter: (node: T, ctx: VisitContext<T>) => EnterResult<T> | void = () => WalkAction.Continue,
  exit: (node: T, ctx: VisitContext<T>) => ExitResult<T> | void = () => WalkAction.Continue,
) {
  type StackFrame = [nodes: T[], offset: number, parent: Parent<T> | null]
  let stack: Stack<StackFrame> | null = { value: [ast, 0, null], prev: null }

  let ctx: VisitContext<T> = {
    parent: null,
    depth: 0,
    path() {
      let path: T[] = []

      let frames: Stack<StackFrame> | null = stack

      while (frames) {
        let parent = frames.value[2]
        if (parent) path.push(parent)
        frames = frames.prev
      }

      path.reverse()

      return path
    },
  }

  while (stack !== null) {
    let frame = stack.value
    let nodes = frame[0]
    let offset = frame[1]
    let parent = frame[2]

    // Done with this level
    if (offset >= nodes.length) {
      stack = stack.prev
      ctx.depth -= 1
      continue
    }

    ctx.parent = parent

    // Enter phase (offsets are positive)
    if (offset >= 0) {
      let node = nodes[offset]
      let result = enter(node, ctx) ?? WalkAction.Continue

      switch (result.kind) {
        case WalkKind.Continue: {
          if (node.nodes && node.nodes.length > 0) {
            ctx.depth += 1
            stack = {
              value: [node.nodes, 0, node as Parent<T>],
              prev: stack,
            }
          }

          frame[1] = ~offset // Prepare for exit phase, same offset
          continue
        }

        case WalkKind.Stop:
          return // Stop immediately

        case WalkKind.Skip: {
          frame[1] = ~offset // Prepare for exit phase, same offset
          continue
        }

        case WalkKind.Replace: {
          nodes.splice(offset, 1, ...result.nodes)
          continue // Re-process at same offset
        }

        case WalkKind.ReplaceStop: {
          nodes.splice(offset, 1, ...result.nodes)
          return // Stop immediately
        }

        case WalkKind.ReplaceSkip: {
          nodes.splice(offset, 1, ...result.nodes)
          frame[1] += result.nodes.length // Advance to next sibling past replacements
          continue
        }

        default: {
          result satisfies never
          throw new Error(
            // @ts-expect-error enterResult.kind may be invalid
            `Invalid \`WalkAction.${WalkKind[result.kind] ?? `Unknown(${result.kind})`}\` in enter.`,
          )
        }
      }
    }

    // Exit phase for nodes[~offset]
    let index = ~offset // Two's complement to get original offset
    let node = nodes[index]

    let result = exit(node, ctx) ?? WalkAction.Continue

    switch (result.kind) {
      case WalkKind.Continue:
        frame[1] = index + 1 // Advance to next sibling
        continue

      case WalkKind.Stop:
        return // Stop immediately

      case WalkKind.Replace: {
        nodes.splice(index, 1, ...result.nodes)
        frame[1] = index + result.nodes.length // Advance to next sibling past replacements
        continue
      }

      case WalkKind.ReplaceStop: {
        nodes.splice(index, 1, ...result.nodes)
        return // Stop immediately
      }

      case WalkKind.ReplaceSkip: {
        nodes.splice(index, 1, ...result.nodes)
        frame[1] = index + result.nodes.length // Advance to next sibling past replacements
        continue
      }

      default: {
        result satisfies never
        throw new Error(
          // @ts-expect-error `result.kind` could still be filled with an invalid value
          `Invalid \`WalkAction.${WalkKind[result.kind] ?? `Unknown(${result.kind})`}\` in exit.`,
        )
      }
    }
  }
}