9978947316

Committed 17 Jul 2024 05:43PM UTC coverage: 31.911% (+0.05%) from 31.861%

Build # 9978947316

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9515 from ForumMagnum/master

[EA] deploy lots of people directory improvements

Run Details

4907 of 40344 branches covered (12.16%)

Branch coverage included in aggregate %.

139 of 266 new or added lines in 49 files covered. (52.26%)

3 existing lines in 3 files now uncovered.

28712 of 65010 relevant lines covered (44.17%)

180.26 hits per line

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

10.15

/packages/lesswrong/components/peopleDirectory/usePeopleDirectory.tsx

import React, { ReactNode, createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";
import { getSearchClient } from "../../lib/search/searchUtil";
import { MultiSelectResult, MultiSelectState, useMultiSelect } from "../hooks/useMultiSelect";
import { CAREER_STAGES } from "../../lib/collections/users/schema";
import { PeopleDirectoryColumn, peopleDirectoryColumns } from "./peopleDirectoryColumns";
import { MULTISELECT_SUGGESTION_LIMIT, SearchableMultiSelectResult, useSearchableMultiSelect } from "../hooks/useSearchableMultiSelect";
import { useSearchAnalytics } from "../search/useSearchAnalytics";
import { captureException } from "@sentry/core";
import { filterNonnull } from "../../lib/utils/typeGuardUtils";
import { useLocation, useNavigate } from "../../lib/routeUtil";
import { taggingNamePluralSetting, taggingNameCapitalSetting } from "@/lib/instanceSettings";
import { algoliaPrefixSetting } from "@/lib/publicSettings";
import qs from "qs";
import { useMulti } from "@/lib/crud/withMulti";
import { gql, useQuery } from "@apollo/client";

type PeopleDirectoryView = "list" | "map";

type PeopleDirectorySorting = {
  field: string,
  direction: "asc" | "desc",
}

const defaultSorting: PeopleDirectorySorting = {
  field: "profileCompletion",
  direction: "desc",
};

type PeopleDirectoryStaticFilterConfig = {
  type: "static",
  filter: MultiSelectResult,
}

type PeopleDirectorySearchableFilterConfig = {
  type: "searchable",
  filter: SearchableMultiSelectResult,
}

type PeopleDirectoryFilterConfig = PeopleDirectoryStaticFilterConfig | PeopleDirectorySearchableFilterConfig;

type PeopleDirectoryContext = {
  view: PeopleDirectoryView,
  setView: (view: PeopleDirectoryView) => void,
  query: string,
  setQuery: (query: string) => void,
  clearSearch: () => void,
  isEmptySearch: boolean,
  sorting: PeopleDirectorySorting,
  setSorting: (sorting: PeopleDirectorySorting | null) => void,
  isDefaultSorting: boolean,
  results: SearchUser[],
  resultsLoading: boolean,
  totalResults: number,
  loadMore: () => void,
  filters: PeopleDirectoryFilterConfig[],
  columns: (PeopleDirectoryColumn & MultiSelectState)[],
  columnsEdited: boolean,
  resetColumns: () => void,
}

const peopleDirectoryContext = createContext<PeopleDirectoryContext | null>(null);

const tagCountQuery = gql`
  query ActiveTagCount {
    ActiveTagCount
  }
`;

export const PeopleDirectoryProvider = ({children}: {children: ReactNode}) => {
  const captureSearch = useSearchAnalytics();
  const navigate = useNavigate();
  const {location, query: urlQuery} = useLocation();
  const [view, setView] = useState<PeopleDirectoryView>("list");
  const [query, setQuery_] = useState(urlQuery.query ?? "");
  const [sorting, setSorting_] = useState<PeopleDirectorySorting>(defaultSorting);
  // We store the results in an 2D-array, where the index in the first array
  // corresponds to the "page" of the contained results. This prevents a class
  // of bugs where updates cause results to be out-of-order or duplicated.
  const [results, setResults] = useState<SearchUser[][]>([]);
  const [resultsLoading, setResultsLoading] = useState(true);
  const [totalResults, setTotalResults] = useState(0);
  const [page, setPage] = useState(0);
  const [numPages, setNumPages] = useState(0);

  const {results: coreTags} = useMulti({
    collectionName: "Tags",
    fragmentName: "TagName",
    terms: {
      view: "coreTags",
      limit: MULTISELECT_SUGGESTION_LIMIT,
    },
  });

  const {data: tagCountResult} = useQuery(tagCountQuery);
  const tagCount = tagCountResult?.ActiveTagCount ?? 0;

  const roles = useSearchableMultiSelect({
    title: "Role",
    facetField: "jobTitle",
  });
  const organizations = useSearchableMultiSelect({
    title: "Organization",
    facetField: "organization",
  });
  const locations = useSearchableMultiSelect({
    title: "Location",
    facetField: "mapLocationAddress",
  });
  const careerStages = useMultiSelect({
    title: "Career stage",
    options: CAREER_STAGES,
  });
  const tags = useSearchableMultiSelect({
    title: `${taggingNameCapitalSetting.get()} interests`,
    placeholder: `Search ${tagCount ? tagCount + " " : ""}${taggingNamePluralSetting.get()}...`,
    elasticField: {index: "tags", fieldName: "name"},
    defaultSuggestions: coreTags?.map(({name}) => name),
  });

  const filters: PeopleDirectoryFilterConfig[] = [
    {
      type: "searchable",
      filter: roles,
    },
    {
      type: "searchable",
      filter: organizations,
    },
    {
      type: "static",
      filter: careerStages,
    },
    {
      type: "searchable",
      filter: locations,
    },
    {
      type: "searchable",
      filter: tags,
    },
  ];

  const flattenedResults = useMemo(() => {
    const flattenedResults = results.flatMap((resultsPage) => resultsPage);
    // HACK: We mostly can't repro the situation that causes undefined values in
    // the results, so instead of finding the root cause we'll just filter them
    // out.
    const hackyNullRemoval = filterNonnull(flattenedResults);
    if (flattenedResults.length !== hackyNullRemoval.length) {
      // eslint-disable-next-line no-console
      console.error("People directory results contained undefined values", flattenedResults);
    }
    return hackyNullRemoval;
  }, [results]);

  const updateUrlQuery = useCallback((update: Record<string, string>) => {
    const newQuery = {...urlQuery, ...update};
    navigate({...location, search: `?${qs.stringify(newQuery)}`});
  }, [navigate, location, urlQuery]);

  const setQuery = useCallback((query: string) => {
    setQuery_(query);
    updateUrlQuery({query});
  }, [updateUrlQuery]);

  const clearSearch = useCallback(() => {
    setQuery("");
    roles.clear();
    organizations.clear();
    locations.clear();
    careerStages.clear();
    tags.clear();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [
    roles.clear,
    organizations.clear,
    locations.clear,
    careerStages.clear,
    tags.clear,
  ]);

  const isEmptySearch = query === "" &&
    roles.selectedValues.length === 0 &&
    organizations.selectedValues.length === 0 &&
    locations.selectedValues.length === 0 &&
    careerStages.selectedValues.length === 0 &&
    tags.selectedValues.length === 0;

  const [columns, setColumns] = useState(peopleDirectoryColumns);
  const [columnsEdited, setColumnsEdited] = useState(false);
  const toggleColumn = useCallback((columnLabel: string) => {
    setColumns((columns) => columns.map((column) => {
      return column.label === columnLabel && column.hideable
        ? {
          ...column,
          hidden: !column.hidden,
        }
        : column;
    }));
    setColumnsEdited(true);
  }, []);
  const resetColumns = useCallback(() => {
    setColumns(peopleDirectoryColumns);
    setColumnsEdited(false);
  }, []);
  const columnSelectState = useMemo(() => {
    return columns.map((column) => ({
      ...column,
      value: column.label,
      label: column.label,
      selected: column.hideable && !column.hidden,
      onToggle: () => toggleColumn(column.label),
    }));
  }, [columns, toggleColumn]);

  const setSorting = useCallback((sorting: PeopleDirectorySorting | null) => {
    setSorting_((oldSorting) => {
      if (
        sorting &&
        sorting.field === oldSorting.field &&
        sorting.direction === oldSorting.direction
      ) {
        return defaultSorting;
      }
      if (sorting) {
        const column = columns.find(
          ({sortField}) => sortField === sorting.field,
        );
        if (column?.hideable && column.hidden) {
          toggleColumn(column.label);
          setColumnsEdited(true);
        }
      }
      return sorting ?? defaultSorting;
    });
  }, [columns, toggleColumn]);

  const isDefaultSorting = sorting === defaultSorting;

  const loadMore = useCallback(() => {
    const newPage = page + 1;
    if (!resultsLoading && newPage < numPages) {
      setPage(newPage);
    }
  }, [resultsLoading, page, numPages]);

  useEffect(() => {
    setResults([]);
    setTotalResults(0);
    setPage(0);
    setNumPages(0);
  }, [
    view,
    query,
    sorting,
    roles.selectedValues,
    organizations.selectedValues,
    locations.selectedValues,
    careerStages.selectedValues,
    tags.selectedValues,
  ]);

  useEffect(() => {
    setResultsLoading(true);
    void (async () => {
      try {
        const isMap = view === "map";
        const sortString = query && isDefaultSorting
          ? ""
          : `_${sorting.field}:${sorting.direction}`;
        const facetFilters = [
          roles.selectedValues.map((role) => `jobTitle:${role}`),
          organizations.selectedValues.map((org) => `organization:${org}`),
          locations.selectedValues.map((location) => `mapLocationAddress:${location}`),
          careerStages.selectedValues.map((stage) => `careerStage:${stage}`),
          tags.selectedValues.map((tag) => `tags.name:${tag}`),
          ["hideFromPeopleDirectory:false"],
          isMap ? ["_geoloc:-null"] : [],
        ];
        const response = await getSearchClient().search([
          {
            indexName: algoliaPrefixSetting.get() + "users" + sortString,
            query,
            params: {
              query,
              facetFilters,
              page,
              hitsPerPage: isMap ? 250 : undefined,
            },
          },
        ]);
        const results = response?.results?.[0];
        const hits = results?.hits ?? [];
        setResults((previousResults) => {
          const newResults = [...previousResults];
          newResults[results?.page ?? 0] = hits;
          return newResults;
        });
        setTotalResults(results?.nbHits ?? 0);
        setNumPages(results?.nbPages ?? 0);
        captureSearch("peopleDirectorySearch", {
          query,
          sorting,
          roles: roles.selectedValues,
          organizations: organizations.selectedValues,
          locations: locations.selectedValues,
          careerStages: careerStages.selectedValues,
          tags: tags.selectedValues,
          hitCount: hits.length,
        });
      } catch (e) {
        // eslint-disable-next-line no-console
        console.error("People directory search error:", e);
        captureException(e);
      } finally {
        setResultsLoading(false);
      }
    })();
  }, [
    captureSearch,
    page,
    view,
    query,
    sorting,
    isDefaultSorting,
    roles.selectedValues,
    organizations.selectedValues,
    locations.selectedValues,
    careerStages.selectedValues,
    tags.selectedValues,
  ]);

  return (
    <peopleDirectoryContext.Provider value={{
      view,
      setView,
      query,
      setQuery,
      clearSearch,
      isEmptySearch,
      sorting,
      setSorting,
      isDefaultSorting,
      results: flattenedResults,
      resultsLoading,
      totalResults,
      loadMore,
      filters,
      columns: columnSelectState,
      columnsEdited,
      resetColumns,
    }}>
      {children}
    </peopleDirectoryContext.Provider>
  );
}

export const usePeopleDirectory = (): PeopleDirectoryContext => {
  const context = useContext(peopleDirectoryContext);
  if (!context) {
    throw new Error("Using people directory context outside of a provider");
  }
  return context;
}

1	import React, { ReactNode, createContext, useCallback, useContext, useEffect, useMemo, useState } from "react";	3✔
2	import { getSearchClient } from "../../lib/search/searchUtil";	1✔
3	import { MultiSelectResult, MultiSelectState, useMultiSelect } from "../hooks/useMultiSelect";	1✔
4	import { CAREER_STAGES } from "../../lib/collections/users/schema";	1✔
5	import { PeopleDirectoryColumn, peopleDirectoryColumns } from "./peopleDirectoryColumns";	1✔
6	import { MULTISELECT_SUGGESTION_LIMIT, SearchableMultiSelectResult, useSearchableMultiSelect } from "../hooks/useSearchableMultiSelect";	1✔
7	import { useSearchAnalytics } from "../search/useSearchAnalytics";	1✔
8	import { captureException } from "@sentry/core";	1✔
9	import { filterNonnull } from "../../lib/utils/typeGuardUtils";	1✔
10	import { useLocation, useNavigate } from "../../lib/routeUtil";	1✔
11	import { taggingNamePluralSetting, taggingNameCapitalSetting } from "@/lib/instanceSettings";	1✔
12	import { algoliaPrefixSetting } from "@/lib/publicSettings";	1✔
13	import qs from "qs";	1✔
14	import { useMulti } from "@/lib/crud/withMulti";	1✔
15	import { gql, useQuery } from "@apollo/client";	1✔
16
17	type PeopleDirectoryView = "list" \| "map";
18
19	type PeopleDirectorySorting = {
20	field: string,
21	direction: "asc" \| "desc",
22	}
23
24	const defaultSorting: PeopleDirectorySorting = {	1✔
25	field: "profileCompletion",
26	direction: "desc",
27	};
28
29	type PeopleDirectoryStaticFilterConfig = {
30	type: "static",
31	filter: MultiSelectResult,
32	}
33
34	type PeopleDirectorySearchableFilterConfig = {
35	type: "searchable",
36	filter: SearchableMultiSelectResult,
37	}
38
39	type PeopleDirectoryFilterConfig = PeopleDirectoryStaticFilterConfig \| PeopleDirectorySearchableFilterConfig;
40
41	type PeopleDirectoryContext = {
42	view: PeopleDirectoryView,
43	setView: (view: PeopleDirectoryView) => void,
44	query: string,
45	setQuery: (query: string) => void,
46	clearSearch: () => void,
47	isEmptySearch: boolean,
48	sorting: PeopleDirectorySorting,
49	setSorting: (sorting: PeopleDirectorySorting \| null) => void,
50	isDefaultSorting: boolean,
51	results: SearchUser[],
52	resultsLoading: boolean,
53	totalResults: number,
54	loadMore: () => void,
55	filters: PeopleDirectoryFilterConfig[],
56	columns: (PeopleDirectoryColumn & MultiSelectState)[],
57	columnsEdited: boolean,
58	resetColumns: () => void,
59	}
60
61	const peopleDirectoryContext = createContext<PeopleDirectoryContext \| null>(null);	1✔
62
63	const tagCountQuery = gql`	1✔
64	query ActiveTagCount {
65	ActiveTagCount
66	}
67	`;
68
69	export const PeopleDirectoryProvider = ({children}: {children: ReactNode}) => {	1✔
70	const captureSearch = useSearchAnalytics();	×
71	const navigate = useNavigate();	×
72	const {location, query: urlQuery} = useLocation();	×
73	const [view, setView] = useState<PeopleDirectoryView>("list");	×
74	const [query, setQuery_] = useState(urlQuery.query ?? "");	×
NEW 75	const [sorting, setSorting_] = useState<PeopleDirectorySorting>(defaultSorting);	×
76	// We store the results in an 2D-array, where the index in the first array
77	// corresponds to the "page" of the contained results. This prevents a class
78	// of bugs where updates cause results to be out-of-order or duplicated.
79	const [results, setResults] = useState<SearchUser[][]>([]);	×
80	const [resultsLoading, setResultsLoading] = useState(true);	×
81	const [totalResults, setTotalResults] = useState(0);	×
82	const [page, setPage] = useState(0);	×
83	const [numPages, setNumPages] = useState(0);	×
84
NEW 85	const {results: coreTags} = useMulti({	×
86	collectionName: "Tags",
87	fragmentName: "TagName",
88	terms: {
89	view: "coreTags",
90	limit: MULTISELECT_SUGGESTION_LIMIT,
91	},
92	});
93
NEW 94	const {data: tagCountResult} = useQuery(tagCountQuery);	×
NEW 95	const tagCount = tagCountResult?.ActiveTagCount ?? 0;	×
96
UNCOV 97	const roles = useSearchableMultiSelect({	×
98	title: "Role",
99	facetField: "jobTitle",
100	});
101	const organizations = useSearchableMultiSelect({	×
102	title: "Organization",
103	facetField: "organization",
104	});
105	const locations = useSearchableMultiSelect({	×
106	title: "Location",
107	facetField: "mapLocationAddress",
108	});
109	const careerStages = useMultiSelect({	×
110	title: "Career stage",
111	options: CAREER_STAGES,
112	});
NEW 113	const tags = useSearchableMultiSelect({	×
114	title: `${taggingNameCapitalSetting.get()} interests`,
115	placeholder: `Search ${tagCount ? tagCount + " " : ""}${taggingNamePluralSetting.get()}...`,	×
116	elasticField: {index: "tags", fieldName: "name"},
NEW 117	defaultSuggestions: coreTags?.map(({name}) => name),	×
118	});
119
NEW 120	const filters: PeopleDirectoryFilterConfig[] = [	×
121	{
122	type: "searchable",
123	filter: roles,
124	},
125	{
126	type: "searchable",
127	filter: organizations,
128	},
129	{
130	type: "static",
131	filter: careerStages,
132	},
133	{
134	type: "searchable",
135	filter: locations,
136	},
137	{
138	type: "searchable",
139	filter: tags,
140	},
141	];
142
143	const flattenedResults = useMemo(() => {	×
144	const flattenedResults = results.flatMap((resultsPage) => resultsPage);	×
145	// HACK: We mostly can't repro the situation that causes undefined values in
146	// the results, so instead of finding the root cause we'll just filter them
147	// out.
148	const hackyNullRemoval = filterNonnull(flattenedResults);	×
149	if (flattenedResults.length !== hackyNullRemoval.length) {	×
150	// eslint-disable-next-line no-console
151	console.error("People directory results contained undefined values", flattenedResults);	×
152	}
153	return hackyNullRemoval;	×
154	}, [results]);
155
156	const updateUrlQuery = useCallback((update: Record<string, string>) => {	×
157	const newQuery = {...urlQuery, ...update};	×
158	navigate({...location, search: `?${qs.stringify(newQuery)}`});	×
159	}, [navigate, location, urlQuery]);
160
161	const setQuery = useCallback((query: string) => {	×
162	setQuery_(query);	×
163	updateUrlQuery({query});	×
164	}, [updateUrlQuery]);
165
166	const clearSearch = useCallback(() => {	×
167	setQuery("");	×
168	roles.clear();	×
169	organizations.clear();	×
170	locations.clear();	×
171	careerStages.clear();	×
NEW 172	tags.clear();	×
173	// eslint-disable-next-line react-hooks/exhaustive-deps
174	}, [
175	roles.clear,
176	organizations.clear,
177	locations.clear,
178	careerStages.clear,
179	tags.clear,
180	]);
181
182	const isEmptySearch = query === "" &&	×
183	roles.selectedValues.length === 0 &&
184	organizations.selectedValues.length === 0 &&
185	locations.selectedValues.length === 0 &&
186	careerStages.selectedValues.length === 0 &&
187	tags.selectedValues.length === 0;
188
189	const [columns, setColumns] = useState(peopleDirectoryColumns);	×
190	const [columnsEdited, setColumnsEdited] = useState(false);	×
191	const toggleColumn = useCallback((columnLabel: string) => {	×
192	setColumns((columns) => columns.map((column) => {	×
193	return column.label === columnLabel && column.hideable	×
194	? {	×
195	...column,
196	hidden: !column.hidden,
197	}
198	: column;
199	}));
200	setColumnsEdited(true);	×
201	}, []);
202	const resetColumns = useCallback(() => {	×
203	setColumns(peopleDirectoryColumns);	×
204	setColumnsEdited(false);	×
205	}, []);
206	const columnSelectState = useMemo(() => {	×
207	return columns.map((column) => ({	×
208	...column,
209	value: column.label,
210	label: column.label,
211	selected: column.hideable && !column.hidden,	×
212	onToggle: () => toggleColumn(column.label),	×
213	}));
214	}, [columns, toggleColumn]);
215
NEW 216	const setSorting = useCallback((sorting: PeopleDirectorySorting \| null) => {	×
NEW 217	setSorting_((oldSorting) => {	×
NEW 218	if (	×
219	sorting &&	×
220	sorting.field === oldSorting.field &&
221	sorting.direction === oldSorting.direction
222	) {
NEW 223	return defaultSorting;	×
224	}
NEW 225	if (sorting) {	×
NEW 226	const column = columns.find(	×
NEW 227	({sortField}) => sortField === sorting.field,	×
228	);
NEW 229	if (column?.hideable && column.hidden) {	×
NEW 230	toggleColumn(column.label);	×
NEW 231	setColumnsEdited(true);	×
232	}
233	}
NEW 234	return sorting ?? defaultSorting;	×
235	});
236	}, [columns, toggleColumn]);
237
NEW 238	const isDefaultSorting = sorting === defaultSorting;	×
239
240	const loadMore = useCallback(() => {	×
241	const newPage = page + 1;	×
242	if (!resultsLoading && newPage < numPages) {	×
243	setPage(newPage);	×
244	}
245	}, [resultsLoading, page, numPages]);
246
247	useEffect(() => {	×
248	setResults([]);	×
249	setTotalResults(0);	×
250	setPage(0);	×
251	setNumPages(0);	×
252	}, [
253	view,
254	query,
255	sorting,
256	roles.selectedValues,
257	organizations.selectedValues,
258	locations.selectedValues,
259	careerStages.selectedValues,
260	tags.selectedValues,
261	]);
262
263	useEffect(() => {	×
264	setResultsLoading(true);	×
265	void (async () => {	×
266	try {	×
267	const isMap = view === "map";	×
NEW 268	const sortString = query && isDefaultSorting	×
269	? ""	×
270	: `_${sorting.field}:${sorting.direction}`;
271	const facetFilters = [	×
272	roles.selectedValues.map((role) => `jobTitle:${role}`),	×
273	organizations.selectedValues.map((org) => `organization:${org}`),	×
274	locations.selectedValues.map((location) => `mapLocationAddress:${location}`),	×
275	careerStages.selectedValues.map((stage) => `careerStage:${stage}`),	×
NEW 276	tags.selectedValues.map((tag) => `tags.name:${tag}`),	×
277	["hideFromPeopleDirectory:false"],
278	isMap ? ["_geoloc:-null"] : [],	×
279	];
280	const response = await getSearchClient().search([	×
281	{
282	indexName: algoliaPrefixSetting.get() + "users" + sortString,
283	query,
284	params: {
285	query,
286	facetFilters,
287	page,
288	hitsPerPage: isMap ? 250 : undefined,	×
289	},
290	},
291	]);
292	const results = response?.results?.[0];	×
293	const hits = results?.hits ?? [];	×
294	setResults((previousResults) => {	×
295	const newResults = [...previousResults];	×
296	newResults[results?.page ?? 0] = hits;	×
297	return newResults;	×
298	});
299	setTotalResults(results?.nbHits ?? 0);	×
300	setNumPages(results?.nbPages ?? 0);	×
301	captureSearch("peopleDirectorySearch", {	×
302	query,
303	sorting,
304	roles: roles.selectedValues,
305	organizations: organizations.selectedValues,
306	locations: locations.selectedValues,
307	careerStages: careerStages.selectedValues,
308	tags: tags.selectedValues,
309	hitCount: hits.length,
310	});
311	} catch (e) {
312	// eslint-disable-next-line no-console
313	console.error("People directory search error:", e);	×
314	captureException(e);	×
315	} finally {
316	setResultsLoading(false);	×
317	}
318	})();
319	}, [
320	captureSearch,
321	page,
322	view,
323	query,
324	sorting,
325	isDefaultSorting,
326	roles.selectedValues,
327	organizations.selectedValues,
328	locations.selectedValues,
329	careerStages.selectedValues,
330	tags.selectedValues,
331	]);
332
333	return (	×
334	<peopleDirectoryContext.Provider value={{
335	view,
336	setView,
337	query,
338	setQuery,
339	clearSearch,
340	isEmptySearch,
341	sorting,
342	setSorting,
343	isDefaultSorting,
344	results: flattenedResults,
345	resultsLoading,
346	totalResults,
347	loadMore,
348	filters,
349	columns: columnSelectState,
350	columnsEdited,
351	resetColumns,
352	}}>
353	{children}
354	</peopleDirectoryContext.Provider>
355	);
356	}
357
358	export const usePeopleDirectory = (): PeopleDirectoryContext => {	1✔
359	const context = useContext(peopleDirectoryContext);	×
360	if (!context) {	×
361	throw new Error("Using people directory context outside of a provider");	×
362	}
363	return context;	×
364	}

ForumMagnum / ForumMagnum / 9978947316

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