10801787475

Committed 10 Sep 2024 10:47PM UTC coverage: 31.87% (-0.001%) from 31.871%

Build # 10801787475

Build Type

Pull #9739

github

Committed by

jimrandomh

Commit Message

Concepts and Community pages have a navigation footer

Makes it so the LW Concepts and Community pages (which are linked to from
the bottom-bar) have bottom-bars themselves.

Disentangles the concept of "having standalone navigation", which
referred to both having left-side ToC-style navigation options at larger
breakpoints, and having a bottom-bar at smaller breakpoints. That didn't
work for the Concepts and Community pages, which have their own tables
of contents and want the bottom-bar without the ToC-style page
navigation.

Pull Request Pull Request #9739: Fix missing navigation footer

Run Details

5070 of 41296 branches covered (12.28%)

Branch coverage included in aggregate %.

2 of 4 new or added lines in 4 files covered. (50.0%)

2 existing lines in 2 files now uncovered.

29399 of 66858 relevant lines covered (43.97%)

185.15 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

50.0

/packages/lesswrong/lib/vulcan-lib/routes.ts

import * as _ from 'underscore';
// eslint-disable-next-line no-restricted-imports
import {matchPath} from 'react-router'
import type { Request, Response } from 'express';

export type PingbackDocument = {
  collectionName: CollectionNameString,
  documentId: string,
};

export type RouterLocation = {
  // Null in 404
  currentRoute: Route|null,
  RouteComponent: any,
  location: any,
  pathname: string,
  url: string,
  hash: string,
  params: Record<string,string>,
  query: Record<string,string>, // TODO: this should be Record<string,string|string[]>
  redirected?: boolean,
};

export type Route = {
  /**
   * Name of the route. Must be unique. In theory, should have no effect; in
   * practice, some components are comparing route names to expected values,
   * which we should refactor to make them not do anymore.
   */
  name: string,
  
  /**
   * URL pattern for this route. Syntax comes from the path-to-regexp library
   * (via indirect dependency via react-router).
   */
  path: string,
  
  componentName?: keyof ComponentTypes,

  title?: string,
  titleComponentName?: keyof ComponentTypes,
  subtitle?: string,
  headerSubtitle?: string,
  subtitleLink?: string,
  subtitleComponentName?: keyof ComponentTypes,
  description?: string,
  redirect?: (location: RouterLocation) => string,
  getPingback?: (parsedUrl: RouterLocation) => Promise<PingbackDocument|null> | PingbackDocument|null,
  previewComponentName?: keyof ComponentTypes,
  _id?: string|null,
  noIndex?: boolean,
  background?: string,
  sunshineSidebar?: boolean
  disableAutoRefresh?: boolean,
  initialScroll?: "top"|"bottom",
  noFooter?: boolean,
  standalone?: boolean // if true, this page has no header / intercom
  staticHeader?: boolean // if true, the page header is not sticky to the top of the screen
  fullscreen?: boolean // if true, the page contents are put into a flexbox with the header such that the page contents take up the full height of the screen without scrolling
  unspacedGrid?: boolean // for routes with standalone navigation, setting this to true allows the page body to be full-width (the default is to have empty columns providing padding)

  hasLeftNavigationColumn?: boolean
  navigationFooterBar?: boolean,
  
  // enableResourcePrefetch: Start loading stylesheet and JS bundle before the page is
  // rendered. This requires sending headers before rendering, which means
  // that the page can't return an HTTP error status or an HTTP redirect. In
  // exchange, loading time is significantly improved for users who don't have
  // the stylesheet and JS bundle already in their cache.
  //
  // This should only return true for routes which are *guaranteed* to return a 200 status code.
  // I.e. it is better to give false negatives (not prefetching on a route that actually returns
  // a 200) than false positives.
  enableResourcePrefetch?: boolean | ((req: Request, res: Response, parsedRoute: RouterLocation, context: ResolverContext) => Promise<boolean>),
  /**
   * Under what circumstances stale-while-revalidate caching should be enabled on this route.
   * If enabled, page loads where this is allowed will have a "Cache-control: max-age=1, s-max-age=1, stale-while-revalidate=86400"
   * header applied, which allows CDNs to cache them for up to 1 day
   */
  swrCaching?: "logged-out"
  isAdmin?: boolean
};

/** Populated by calls to addRoute */
export const Routes: Record<string,Route> = {};

// Add a route to the routes table.
//
// Because routes have a bunch of optional fields and fields with constrained
// strings (for component names), merging the types of a bunch of route
// definitions in an array would produce an incorrect type. So instead of taking
// an array argument, take varargs, which preserve the original type.
export const addRoute = (...routes: Route[]): void => {
  for (let route of routes) {
    const {name, path, ...properties} = route;
  
    // check if there is already a route registered to this path
    // @ts-ignore The @types/underscore signature for _.findWhere is narrower than the real function; this works fine
    const routeWithSamePath = _.findWhere(Routes, { path });
  
    if (routeWithSamePath) {
      // Don't allow shadowing/replacing routes
      throw new Error(`Conflicting routes with path ${path}`);
    }
    
    // Check for name collisions
    if (Routes[name]) {
      throw new Error(`Conflicting routes with name ${name}`);
    }
  
    // register the new route
    Routes[name] = {
      name,
      path,
      ...properties
    };
  }
};

export const getRouteMatchingPathname = (pathname: string): Route | undefined  => {
  return Object.values(Routes).reverse().find((route) => matchPath(pathname, {
    path: route.path,
    exact: true,
    strict: false,
  }))
}

export const userCanAccessRoute = (user?: UsersCurrent | DbUser | null, route?: Route | null): boolean => {
  if (!route) return true // Anyone can access a non-existent route (which would 404)
  if (user?.isAdmin) return true

  return !route.isAdmin
}

1	import * as _ from 'underscore';	1,356✔
2	// eslint-disable-next-line no-restricted-imports
3	import {matchPath} from 'react-router'	46✔
4	import type { Request, Response } from 'express';
5
6	export type PingbackDocument = {
7	collectionName: CollectionNameString,
8	documentId: string,
9	};
10
11	export type RouterLocation = {
12	// Null in 404
13	currentRoute: Route\|null,
14	RouteComponent: any,
15	location: any,
16	pathname: string,
17	url: string,
18	hash: string,
19	params: Record<string,string>,
20	query: Record<string,string>, // TODO: this should be Record<string,string\|string[]>
21	redirected?: boolean,
22	};
23
24	export type Route = {
25	/**
26	* Name of the route. Must be unique. In theory, should have no effect; in
27	* practice, some components are comparing route names to expected values,
28	* which we should refactor to make them not do anymore.
29	*/
30	name: string,
31
32	/**
33	* URL pattern for this route. Syntax comes from the path-to-regexp library
34	* (via indirect dependency via react-router).
35	*/
36	path: string,
37
38	componentName?: keyof ComponentTypes,
39
40	title?: string,
41	titleComponentName?: keyof ComponentTypes,
42	subtitle?: string,
43	headerSubtitle?: string,
44	subtitleLink?: string,
45	subtitleComponentName?: keyof ComponentTypes,
46	description?: string,
47	redirect?: (location: RouterLocation) => string,
48	getPingback?: (parsedUrl: RouterLocation) => Promise<PingbackDocument\|null> \| PingbackDocument\|null,
49	previewComponentName?: keyof ComponentTypes,
50	_id?: string\|null,
51	noIndex?: boolean,
52	background?: string,
53	sunshineSidebar?: boolean
54	disableAutoRefresh?: boolean,
55	initialScroll?: "top"\|"bottom",
56	noFooter?: boolean,
57	standalone?: boolean // if true, this page has no header / intercom
58	staticHeader?: boolean // if true, the page header is not sticky to the top of the screen
59	fullscreen?: boolean // if true, the page contents are put into a flexbox with the header such that the page contents take up the full height of the screen without scrolling
60	unspacedGrid?: boolean // for routes with standalone navigation, setting this to true allows the page body to be full-width (the default is to have empty columns providing padding)
61
62	hasLeftNavigationColumn?: boolean
63	navigationFooterBar?: boolean,
64
65	// enableResourcePrefetch: Start loading stylesheet and JS bundle before the page is
66	// rendered. This requires sending headers before rendering, which means
67	// that the page can't return an HTTP error status or an HTTP redirect. In
68	// exchange, loading time is significantly improved for users who don't have
69	// the stylesheet and JS bundle already in their cache.
70	//
71	// This should only return true for routes which are guaranteed to return a 200 status code.
72	// I.e. it is better to give false negatives (not prefetching on a route that actually returns
73	// a 200) than false positives.
74	enableResourcePrefetch?: boolean \| ((req: Request, res: Response, parsedRoute: RouterLocation, context: ResolverContext) => Promise<boolean>),
75	/**
76	* Under what circumstances stale-while-revalidate caching should be enabled on this route.
77	* If enabled, page loads where this is allowed will have a "Cache-control: max-age=1, s-max-age=1, stale-while-revalidate=86400"
78	* header applied, which allows CDNs to cache them for up to 1 day
79	*/
80	swrCaching?: "logged-out"
81	isAdmin?: boolean
82	};
83
84	/** Populated by calls to addRoute */
85	export const Routes: Record<string,Route> = {};	46✔
86
87	// Add a route to the routes table.
88	//
89	// Because routes have a bunch of optional fields and fields with constrained
90	// strings (for component names), merging the types of a bunch of route
91	// definitions in an array would produce an incorrect type. So instead of taking
92	// an array argument, take varargs, which preserve the original type.
93	export const addRoute = (...routes: Route[]): void => {	46✔
94	for (let route of routes) {	1,217✔
95	const {name, path, ...properties} = route;	3,894✔
96
97	// check if there is already a route registered to this path
98	// @ts-ignore The @types/underscore signature for _.findWhere is narrower than the real function; this works fine
99	const routeWithSamePath = _.findWhere(Routes, { path });	3,894✔
100
101	if (routeWithSamePath) {	3,894!
102	// Don't allow shadowing/replacing routes
103	throw new Error(`Conflicting routes with path ${path}`);	×
104	}
105
106	// Check for name collisions
107	if (Routes[name]) {	3,894!
108	throw new Error(`Conflicting routes with name ${name}`);	×
109	}
110
111	// register the new route
112	Routes[name] = {	3,894✔
113	name,
114	path,
115	...properties
116	};
117	}
118	};
119
120	export const getRouteMatchingPathname = (pathname: string): Route \| undefined => {	46✔
UNCOV 121	return Object.values(Routes).reverse().find((route) => matchPath(pathname, {	×
122	path: route.path,
123	exact: true,
124	strict: false,
125	}))
126	}
127
128	export const userCanAccessRoute = (user?: UsersCurrent \| DbUser \| null, route?: Route \| null): boolean => {	46✔
129	if (!route) return true // Anyone can access a non-existent route (which would 404)	×
130	if (user?.isAdmin) return true	×
131
132	return !route.isAdmin	×
133	}

ForumMagnum / ForumMagnum / 10801787475

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous