Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Update react router documentation #1971

Open
wants to merge 2 commits into
base: main
Choose a base branch
from

Conversation

RohanRajGautam
Copy link

@RohanRajGautam RohanRajGautam commented Apr 21, 2023

Updating existing documentation to its latest version

This PR updates the React Router documentation to version 6.10.0, and ensures that the documentation's entry in the about_tmpl.coffee file matches its data in self.attribution.

  • Updated the versions and releases in the scraper file located at lib/docs/scrapper/react_router.rb.
  • Updated the favicon.ico link in SOURCE located in public/icons/docs/react_router to the latest version.
  • Ensured the icons and the SOURCE file in public/icons/docs/react_router are up-to-date.
  • Ensured self.links contains up-to-date urls if self.links is defined.

Tested the changes locally to ensure:

  • The scraper still works without errors.
  • The scraped documentation still looks consistent with the rest of DevDocs.
  • The categorization of entries is still good.

Checklist

Please make sure that your PR fulfills the following requirements:

  • The PR title is descriptive and clear.
  • Changes are in a separate branch and follow the naming convention: fix/<issue-number>-short-description.
  • The PR description clearly describes the problem and the solution.
  • Code is properly formatted and follows the project's style guide.
  • All tests are passing.
  • The branch is up-to-date with the base branch.

Related Issues

Closes #1970

@RohanRajGautam RohanRajGautam requested a review from a team as a code owner April 21, 2023 18:43
Copy link
Contributor

@simon04 simon04 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

lib/docs/filters/react_router/clean_html.rb and lib/docs/filters/react_router/entries.rb need to be updated. Does not work at all in the current form:

> bundle exec thor docs:generate --force --package react_router
Entries: (2 KB, -23 KB)                                                                                                                                                                                                                                                   
  Updated: 21                                                                                                                                                                                                                                                             
  Created: 0                                                                                                                                                                                                                                                              
  Deleted: 266                                                                                                                                                                                                                                                            
    - <BrowserRouter>                                                                                                                                                                                                                                                     
    - <Form>                                                                                                                                                                                                                                                              
    - <HashRouter>                                                                                                                                                                                                                                                        
    - <Link>                                                                                                                                                                                                                                                              
    - <Link> (React Native)                                                                                                                                                                                                                                               
    - <MemoryRouter>                                                                                                                                                                                                                                                      
    - <NativeRouter>                                                                                                                                                                                                                                                      
    - <Navigate>                                                                                                                                                                                                                                                          
    - <NavLink>                                                                                                                                                                                                                                                           
    - <Outlet>                                                                                                                                                                                                                                                            
    - <Route> doesn't render? How do I compose?                                                                                                                                                                                                                           
    - <Router>                                                                                                                                                                                                                                                            
    - <RouterProvider>                                                                                                                                                                                                                                                    
    - <Routes>                                                                                                                                                                                                                                                            
    - <ScrollRestoration />                                                                                                                                                                                                                                               
    - <StaticRouter>                                                                                                                                                                                                                                                      
    - Abstractions                                                                                                                                                                                                                                                        
    - Accessing Data in Components                                                                                                                                                                                                                                        
    - action                                                                                                                                                                                                                                                              
    - action                                                                                                                                                                                                                                                              
    - action                                                                                                                                                                                                                                                              
    - Active Link Styling                                                                                                                                                                                                                                                 
    - Adding a Router                                                                                                                                                                                                                                                     
    - Adding Search Spinner                                                                                                                                                                                                                                               
    - Auth Example                                                                                                                                                                                                                                                        
    - basename                                                                                                                                                                                                                                                            
    - Basic Example                                                                                                                                                                                                                                                       
    - Breadcrumbs                                                                                                                                                                                                                                                         
    - Bubbling                                                                                                                                                                                                                                                            
    - Building                                                                                                                                                                                                                                                            
    - Cancel Button                                                                                                                                                                                                                                                       
    - caseSensitive                                                                                                                                                                                                                                                       
    - children                                                                                                                                                                                                                                                            
    - Conclusion                                                                                                                                                                                                                                                          
    - Contextual Errors                                                                                                                                                                                                                                                   
    - Contributing to React Router                                                                                                                                                                                                                                        
    - createBrowserRouter                                                                                                                                                                                                                                                 
    - createHashRouter                                                                                                                                                                                                                                                    
    - createMemoryRouter                                                                                                                                                                                                                                                  
    - createRoutesFromChildren                                                                                                                                                                                                                                            
    - createRoutesFromElements                                                                                                                                                                                                                                            
    - createSearchParams                                                                                                                                                                                                                                                  
    - Creating Contacts                                                                                                                                                                                                                                                   
    - Custom Filter Link Example                                                                                                                                                                                                                                          
    - Custom Link Example                                                                                                                                                                                                                                                 
    - Custom Query Parsing Example                                                                                                                                                                                                                                        
    - Data Access                                                                                                                                                                                                                                                         
    - Data Library Integration                                                                                                                                                                                                                                            
    - Data Router Server-side Rendering Example                                                                                                                                                                                                                           
    - Data Routers                                                                                                                                                                                                                                                        
    - Data Routers                                                                                                                                                                                                                                                        
    - Data Writes + HTML Forms                                                                                                                                                                                                                                            
    - defer                                                                                                                                                                                                                                                               
    - Deferred Data Guide                                                                                                                                                                                                                                                 
    - Defining Routes                                                                                                                                                                                                                                                     
    - Definitions                                                                                                                                                                                                                                                         
    - Deleting Records                                                                                                                                                                                                                                                    
    - Development                                                                                                                                                                                                                                                         
    - Docs + Examples                                                                                                                                                                                                                                                     
    - element                                                                                                                                                                                                                                                             
    - Error Boundaries                                                                                                                                                                                                                                                    
    - errorElement                                                                                                                                                                                                                                                        
    - errorElement                                                                                                                                                                                                                                                        
    - Evaluating the solution                                                                                                                                                                                                                                             
    - Examples                                                                                                                                                                                                                                                            
    - fallbackElement                                                                                                                                                                                                                                                     
    - FAQ                                                                                                                                                                                                                                                                 
    - FAQs                                                                                                                                                                                                                                                                
    - Feature Overview                                                                                                                                                                                                                                                    
    - fetcher.data                                                                                                                                                                                                                                                        
    - fetcher.Form                                                                                                                                                                                                                                                        
    - fetcher.formAction                                                                                                                                                                                                                                                  
    - fetcher.formData                                                                                                                                                                                                                                                    
    - fetcher.formMethod                                                                                                                                                                                                                                                  
    - fetcher.load()                                                                                                                                                                                                                                                      
    - fetcher.state                                                                                                                                                                                                                                                       
    - fetcher.submit()                                                                                                                                                                                                                                                    
    - generatePath                                                                                                                                                                                                                                                        
    - GET submissions                                                                                                                                                                                                                                                     
    - GET Submissions with Client Side Routing                                                                                                                                                                                                                            
    - getKey                                                                                                                                                                                                                                                              
    - Global Pending UI                                                                                                                                                                                                                                                   
    - Handling Not Found Errors                                                                                                                                                                                                                                           
    - History and Locations                                                                                                                                                                                                                                               
    - History Object                                                                                                                                                                                                                                                      
    - Hot-fix Releases                                                                                                                                                                                                                                                    
    - How do I add a No Match (404) Route in react-router v6?                                                                                                                                                                                                             
    - How do I nest routes deep in the tree?                                                                                                                                                                                                                              
    - index                                                                                                                                                                                                                                                               
    - Index Query Param                                                                                                                                                                                                                                                   
    - Index Route                                                                                                                                                                                                                                                         
    - Index Routes                                                                                                                                                                                                                                                        
    - Index Routes                                                                                                                                                                                                                                                        
    - init                                                                                                                                                                                                                                                                
    - initialEntries                                                                                                                                                                                                                                                      
    - initialIndex                                                                                                                                                                                                                                                        
    - Invalidating Data in Mutations                                                                                                                                                                                                                                      
    - isRouteErrorResponse                                                                                                                                                                                                                                                
    - Issue Not Getting Attention?                                                                                                                                                                                                                                        
    - json                                                                                                                                                                                                                                                                
    - JSX Routes                                                                                                                                                                                                                                                          
    - Large List Filtering                                                                                                                                                                                                                                                
    - Latest Major Releases                                                                                                                                                                                                                                               
    - Layout Routes                                                                                                                                                                                                                                                       
    - Layout Routes                                                                                                                                                                                                                                                       
    - Lazy Loading Example                                                                                                                                                                                                                                                
    - Link                                                                                                                                                                                                                                                                
    - loader                                                                                                                                                                                                                                                              
    - loader                                                                                                                                                                                                                                                              
    - Loading Data                                                                                                                                                                                                                                                        
    - Loading Data                                                                                                                                                                                                                                                        
    - Location                                                                                                                                                                                                                                                            
    - Locations                                                                                                                                                                                                                                                           
    - Main Concepts                                                                                                                                                                                                                                                       
    - Making a Pull Request?                                                                                                                                                                                                                                              
    - Managing the History Stack                                                                                                                                                                                                                                          
    - Match Params                                                                                                                                                                                                                                                        
    - Matching                                                                                                                                                                                                                                                            
    - matchPath                                                                                                                                                                                                                                                           
    - matchRoutes                                                                                                                                                                                                                                                         
    - method                                                                                                                                                                                                                                                              
    - Modal Example                                                                                                                                                                                                                                                       
    - Multi App Example                                                                                                                                                                                                                                                   
    - Mutation Discussion                                                                                                                                                                                                                                                 
    - Mutation Submissions                                                                                                                                                                                                                                                
    - Mutations Without Navigation                                                                                                                                                                                                                                        
    - Navigate Function                                                                                                                                                                                                                                                   
    - Navigating                                                                                                                                                                                                                                                          
    - navigation.formData                                                                                                                                                                                                                                                 
    - navigation.location                                                                                                                                                                                                                                                 
    - navigation.state                                                                                                                                                                                                                                                    
    - New Releases                                                                                                                                                                                                                                                        
    - Not Found Data                                                                                                                                                                                                                                                      
    - Notes                                                                                                                                                                                                                                                               
    - Other props                                                                                                                                                                                                                                                         
    - Outlets                                                                                                                                                                                                                                                             
    - Packages                                                                                                                                                                                                                                                            
    - params                                                                                                                                                                                                                                                              
    - params                                                                                                                                                                                                                                                              
    - path                                                                                                                                                                                                                                                                
    - Pathless Routes                                                                                                                                                                                                                                                     
    - Pathless Routes                                                                                                                                                                                                                                                     
    - Picking a Router                                                                                                                                                                                                                                                    
    - Preventing Scroll Reset                                                                                                                                                                                                                                             
    - preventScrollReset                                                                                                                                                                                                                                                  
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Preview                                                                                                                                                                                                                                                             
    - Previous Versions                                                                                                                                                                                                                                                   
    - Proposing New or Changed API?                                                                                                                                                                                                                                       
    - Ranking Routes                                                                                                                                                                                                                                                      
    - React Native                                                                                                                                                                                                                                                        
    - React Router Examples                                                                                                                                                                                                                                               
    - react-router@next Releases                                                                                                                                                                                                                                          
    - redirect                                                                                                                                                                                                                                                            
    - Redirecting new records to the edit page                                                                                                                                                                                                                            
    - relative                                                                                                                                                                                                                                                            
    - relative                                                                                                                                                                                                                                                            
    - reloadDocument                                                                                                                                                                                                                                                      
    - Rendering                                                                                                                                                                                                                                                           
    - renderMatches                                                                                                                                                                                                                                                       
    - replace                                                                                                                                                                                                                                                             
    - Repository Branching                                                                                                                                                                                                                                                
    - request                                                                                                                                                                                                                                                             
    - request                                                                                                                                                                                                                                                             
    - resolvePath                                                                                                                                                                                                                                                         
    - Returning Responses                                                                                                                                                                                                                                                 
    - Returning Responses                                                                                                                                                                                                                                                 
    - revalidator.revalidate()                                                                                                                                                                                                                                            
    - revalidator.state                                                                                                                                                                                                                                                   
    - Review                                                                                                                                                                                                                                                              
    - Route                                                                                                                                                                                                                                                               
    - Route APIs                                                                                                                                                                                                                                                          
    - Route Matches                                                                                                                                                                                                                                                       
    - Route Objects Example                                                                                                                                                                                                                                               
    - routes                                                                                                                                                                                                                                                              
    - Scroll Flashing                                                                                                                                                                                                                                                     
    - Search Params Example                                                                                                                                                                                                                                               
    - Server-Side Rendering                                                                                                                                                                                                                                               
    - Server-side Rendering Example                                                                                                                                                                                                                                       
    - Setup                                                                                                                                                                                                                                                               
    - Setup                                                                                                                                                                                                                                                               
    - shouldRevalidate                                                                                                                                                                                                                                                    
    - Splats                                                                                                                                                                                                                                                              
    - Submit options                                                                                                                                                                                                                                                      
    - Submit target                                                                                                                                                                                                                                                       
    - Submitting Forms onChange                                                                                                                                                                                                                                           
    - Synchronizing URLs to Form State                                                                                                                                                                                                                                    
    - Testing                                                                                                                                                                                                                                                             
    - Testing                                                                                                                                                                                                                                                             
    - Tests                                                                                                                                                                                                                                                               
    - The Contact Route UI                                                                                                                                                                                                                                                
    - The Overlap                                                                                                                                                                                                                                                         
    - The problem                                                                                                                                                                                                                                                         
    - The Root Route                                                                                                                                                                                                                                                      
    - The solution                                                                                                                                                                                                                                                        
    - Think You Found a Bug?                                                                                                                                                                                                                                              
    - Throwing in Actions                                                                                                                                                                                                                                                 
    - Throwing in Loaders                                                                                                                                                                                                                                                 
    - Throwing Manually                                                                                                                                                                                                                                                   
    - Throwing Responses                                                                                                                                                                                                                                                  
    - Tutorial                                                                                                                                                                                                                                                            
    - Type Declaration                                                                                                                                                                                                                                                    
    - Type Declaration                                                                                                                                                                                                                                                    
    - Type declaration                                                                                                                                                                                                                                                    
    - Type Declaration                                                                                                                                                                                                                                                    
    - Type Declaration                                                                                                                                                                                                                                                    
    - Type declaration                                                                                                                                                                                                                                                    
    - Type Declaration                                                                                                                                                                                                                                                    
    - Updating Contacts with FormData                                                                                                                                                                                                                                     
    - Updating Data                                                                                                                                                                                                                                                       
    - url                                                                                                                                                                                                                                                                 
    - URL Params in Loaders                                                                                                                                                                                                                                               
    - URL Search Params and GET Submissions                                                                                                                                                                                                                               
    - Usage with defer                                                                                                                                                                                                                                                    
    - useActionData                                                                                                                                                                                                                                                       
    - useAsyncError                                                                                                                                                                                                                                                       
    - useAsyncValue                                                                                                                                                                                                                                                       
    - useFetcher                                                                                                                                                                                                                                                          
    - useFetchers                                                                                                                                                                                                                                                         
    - useFormAction                                                                                                                                                                                                                                                       
    - useHref                                                                                                                                                                                                                                                             
    - useInRouterContext                                                                                                                                                                                                                                                  
    - useLinkClickHandler                                                                                                                                                                                                                                                 
    - useLinkPressHandler                                                                                                                                                                                                                                                 
    - useLoaderData                                                                                                                                                                                                                                                       
    - useLocation                                                                                                                                                                                                                                                         
    - useMatch                                                                                                                                                                                                                                                            
    - useMatches                                                                                                                                                                                                                                                          
    - useNavigate                                                                                                                                                                                                                                                         
    - useNavigation                                                                                                                                                                                                                                                       
    - useNavigationType                                                                                                                                                                                                                                                   
    - useOutlet                                                                                                                                                                                                                                                           
    - useOutletContext                                                                                                                                                                                                                                                    
    - useParams                                                                                                                                                                                                                                                           
    - useResolvedPath                                                                                                                                                                                                                                                     
    - useRevalidator                                                                                                                                                                                                                                                      
    - useRouteError                                                                                                                                                                                                                                                       
    - useRouteLoaderData                                                                                                                                                                                                                                                  
    - useRoutes                                                                                                                                                                                                                                                           
    - useSearchParams                                                                                                                                                                                                                                                     
    - useSearchParams (React Native)                                                                                                                                                                                                                                      
    - useSubmit                                                                                                                                                                                                                                                           
    - Using defer                                                                                                                                                                                                                                                         
    - Using v6.4 Data APIs                                                                                                                                                                                                                                                
    - Web Projects                                                                                                                                                                                                                                                        
    - What Happened to Regexp Routes Paths?                                                                                                                                                                                                                               
    - What happened to withRouter? I need it!                                                                                                                                                                                                                             
    - When does the <Suspense/> fallback render?                                                                                                                                                                                                                          
    - Why does <Route> have an element prop instead of render or component?                                                                                                                                                                                               
    - Why not defer everything by default?                                                                                                                                                                                                                                
    - window                                                                                                                                                                                                                                                              
    - Working With FormData                                                                                                                                                                                                                                               
Types:                                                                                                                                                                                                                                                                    
  Updated: 1                                                                                                                                                                                                                                                              
  Created: 0                                                                                                                                                                                                                                                              
  Deleted: 10                                                                                                                                                                                                                                                             
    - Components                                                                                                                                                                                                                                                          
    - Examples                                                                                                                                                                                                                                                            
    - Fetch                                                                                                                                                                                                                                                               
    - Guides                                                                                                                                                                                                                                                              
    - Hooks                                                                                                                                                                                                                                                               
    - Route                                                                                                                                                                                                                                                               
    - Router-components                                                                                                                                                                                                                                                   
    - Routers                                                                                                                                                                                                                                                             
    - Start                                                                                                                                                                                                                                                               
    - Utils                                                                                                                                                                                                                                                               
Files: (0.1 MB, -0.5 MB)                                                                                                                                                                                                                                                  
  Updated: 1                                                                                                                                                                                                                                                              
  Created: 0                                                                                                                                                                                                                                                              
  Deleted: 95                                                                                                                                                                                                                                                             
    - start/overview                                                                                                                                                                                                                                                      
    - routers/create-browser-router                                                                                                                                                                                                                                       
    - routers/create-memory-router                                                                                                                                                                                                                                        
    - start/examples                                                                                                                                                                                                                                                      
    - routers/picking-a-router                                                                                                                                                                                                                                            
    - router-components/memory-router                                                                                                                                                                                                                                     
    - router-components/browser-router                                                                                                                                                                                                                                    
    - router-components/hash-router                                                                                                                                                                                                                                       
    - router-components/native-router                                                                                                                                                                                                                                     
    - routers/create-hash-router                                                                                                                                                                                                                                          
    - router-components/static-router                                                                                                                                                                                                                                     
    - routers/router-provider                                                                                                                                                                                                                                             
    - router-components/router                                                                                                                                                                                                                                            
    - route/route                                                                                                                                                                                                                                                         
    - route/should-revalidate                                                                                                                                                                                                                                             
    - start/faq                                                                                                                                                                                                                                                           
    - route/action                                                                                                                                                                                                                                                        
    - components/link                                                                                                                                                                                                                                                     
    - components/link-native                                                                                                                                                                                                                                              
    - components/outlet                                                                                                                                                                                                                                                   
    - components/route                                                                                                                                                                                                                                                    
    - components/routes                                                                                                                                                                                                                                                   
    - route/loader                                                                                                                                                                                                                                                        
    - examples                                                                                                                                                                                                                                                            
    - components/navigate                                                                                                                                                                                                                                                 
    - examples/error-boundaries                                                                                                                                                                                                                                           
    - components/nav-link                                                                                                                                                                                                                                                 
    - examples/basic                                                                                                                                                                                                                                                      
    - examples/notes                                                                                                                                                                                                                                                      
    - components/scroll-restoration                                                                                                                                                                                                                                       
    - examples/data-router                                                                                                                                                                                                                                                
    - examples/auth                                                                                                                                                                                                                                                       
    - examples/lazy-loading                                                                                                                                                                                                                                               
    - start/concepts                                                                                                                                                                                                                                                      
    - components/form                                                                                                                                                                                                                                                     
    - examples/scroll-restoration                                                                                                                                                                                                                                         
    - route/error-element                                                                                                                                                                                                                                                 
    - examples/custom-filter-link                                                                                                                                                                                                                                         
    - examples/modal                                                                                                                                                                                                                                                      
    - examples/custom-query-parsing                                                                                                                                                                                                                                       
    - examples/multi-app                                                                                                                                                                                                                                                  
    - examples/search-params                                                                                                                                                                                                                                              
    - examples/ssr                                                                                                                                                                                                                                                        
    - examples/custom-link                                                                                                                                                                                                                                                
    - examples/route-objects                                                                                                                                                                                                                                              
    - hooks/use-form-action                                                                                                                                                                                                                                               
    - hooks/use-async-error                                                                                                                                                                                                                                               
    - hooks/use-href                                                                                                                                                                                                                                                      
    - hooks/use-match                                                                                                                                                                                                                                                     
    - hooks/use-fetcher                                                                                                                                                                                                                                                   
    - hooks/use-fetchers                                                                                                                                                                                                                                                  
    - examples/ssr-data-router                                                                                                                                                                                                                                            
    - hooks/use-loader-data                                                                                                                                                                                                                                               
    - hooks/use-async-value                                                                                                                                                                                                                                               
    - hooks/use-in-router-context                                                                                                                                                                                                                                         
    - hooks/use-action-data                                                                                                                                                                                                                                               
    - hooks/use-location                                                                                                                                                                                                                                                  
    - hooks/use-navigation                                                                                                                                                                                                                                                
    - hooks/use-navigate                                                                                                                                                                                                                                                  
    - hooks/use-link-click-handler                                                                                                                                                                                                                                        
    - hooks/use-outlet                                                                                                                                                                                                                                                    
    - hooks/use-outlet-context                                                                                                                                                                                                                                            
    - hooks/use-link-press-handler                                                                                                                                                                                                                                        
    - hooks/use-navigation-type                                                                                                                                                                                                                                           
    - hooks/use-resolved-path                                                                                                                                                                                                                                             
    - hooks/use-params                                                                                                                                                                                                                                                    
    - hooks/use-matches                                                                                                                                                                                                                                                   
    - hooks/use-revalidator                                                                                                                                                                                                                                               
    - hooks/use-route-error                                                                                                                                                                                                                                               
    - utils/create-routes-from-children                                                                                                                                                                                                                                   
    - hooks/use-routes                                                                                                                                                                                                                                                    
    - hooks/use-search-params                                                                                                                                                                                                                                             
    - hooks/use-search-params-rn                                                                                                                                                                                                                                          
    - utils/defer                                                                                                                                                                                                                                                         
    - hooks/use-submit                                                                                                                                                                                                                                                    
    - start/tutorial                                                                                                                                                                                                                                                      
    - utils/location                                                                                                                                                                                                                                                      
    - utils/match-routes                                                                                                                                                                                                                                                  
    - utils/is-route-error-response                                                                                                                                                                                                                                       
    - utils/create-routes-from-elements                                                                                                                                                                                                                                   
    - utils/generate-path                                                                                                                                                                                                                                                 
    - utils/match-path                                                                                                                                                                                                                                                    
    - fetch/redirect                                                                                                                                                                                                                                                      
    - fetch/json                                                                                                                                                                                                                                                          
    - guides/form-data                                                                                                                                                                                                                                                    
    - utils/create-search-params                                                                                                                                                                                                                                          
    - utils/render-matches                                                                                                                                                                                                                                                
    - utils/resolve-path                                                                                                                                                                                                                                                  
    - guides/ssr                                                                                                                                                                                                                                                          
    - guides/deferred                                                                                                                                                                                                                                                     
    - guides/contributing                                                                                                                                                                                                                                                 
    - guides/index-search-param                                                                                                                                                                                                                                           
    - guides/index-route                                                                                                                                                                                                                                                  
    - guides/data-libs                                                                                                                                                                                                                                                    
    - hooks/use-route-loader-data                                                                                                                                                                                                                                         
Done

@RohanRajGautam
Copy link
Author

RohanRajGautam commented Jun 12, 2023

bundle exec thor docs:generate --force --package react_router

bundle exec thor docs:generate --force --package react_router

Entries: (2 KB, +0 KB)                                                                                                       
  Updated: 21                                                                                                                
  Created: 0                                                                                                                 
  Deleted: 0                                                                                                                 
Types:                                                                                                                       
  Updated: 1                                                                                                                 
  Created: 0                                                                                                                 
  Deleted: 0                                                                                                                 
Files: (0.1 MB, +0.0 MB)                                                                                                     
  Updated: 1                                                                                                                 
  Created: 0                                                                                                                 
  Deleted: 0                                                                                                                 
Done

Sorry for the late response. It is working fine on my end, can you specify what other changes should i make, I am a little bit confused about this one. Thanks!

@simon04
Copy link
Contributor

simon04 commented Jul 3, 2023

Plenty of pages were missing since everything "outside" self.base_url is omitted.

There're still some problems, e.g. https://reactrouter.com/en/6.14.1/router-components/hash-router cannot be scraped since its entire content is encoded as JavaScript and stored as global variable window.__remixContext...

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

React Router hyperlinks can't be reached
2 participants