8741035643

Committed 18 Apr 2024 03:56PM UTC coverage: 32.06% (-0.01%) from 32.072%

Build # 8741035643

Build Type

push

github

Committed by

oetherington

Commit Message

Move localgroups into elastic search and update community map

Co-authored-by: s-cheng <sarah.cheng@centreforeffectivealtruism.org>

Run Details

4692 of 38185 branches covered (12.29%)

Branch coverage included in aggregate %.

9 of 46 new or added lines in 7 files covered. (19.57%)

3 existing lines in 2 files now uncovered.

27384 of 61865 relevant lines covered (44.26%)

180.97 hits per line

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

17.5

/packages/lesswrong/components/localGroups/CommunityMap.tsx

import React, { useState, useCallback, useMemo, useEffect } from 'react';
import { Components, registerComponent } from '../../lib/vulcan-lib';
import { useMulti } from '../../lib/crud/withMulti';
import { createStyles } from '@material-ui/core/styles';
import { userGetDisplayName, userGetProfileUrl } from '../../lib/collections/users/helpers';
import { useLocation } from '../../lib/routeUtil';
import BadlyTypedReactMapGL, { Marker as BadlyTypedMarker } from 'react-map-gl';
import * as _ from 'underscore';
import { mapboxAPIKeySetting } from '../../lib/publicSettings';
import PersonIcon from '@material-ui/icons/Person';
import classNames from 'classnames';
import { componentWithChildren, Helmet } from '../../lib/utils/componentsWithChildren';
import {isFriendlyUI} from '../../themes/forumTheme'
import { filterNonnull } from '../../lib/utils/typeGuardUtils';
import { spreadMapMarkers } from '../../lib/utils/spreadMapMarkers';
import { useSearch } from '../../lib/search/searchUtil';

const ReactMapGL = componentWithChildren(BadlyTypedReactMapGL);
const Marker = componentWithChildren(BadlyTypedMarker);

const styles = createStyles((theme: ThemeType): JssStyles => ({
  root: {
    width: "100%",
    height: 440,
    // We give this a negative margin to make sure that the map is flush with the top
    marginTop: -50,
    [theme.breakpoints.down('sm')]: {
      marginTop: 0,
      marginLeft: -8
    },
    position: "relative",
    boxShadow: theme.palette.boxShadow.default,
    
    "& .mapboxgl-popup-content": {
      background: theme.palette.panelBackground.default,
    },
    "& .StyledMapPopup-markerPageLink": {
      color: theme.palette.text.normal,
    },
  },
  communityMap: {},
  mapButton: {
    padding: 10,
    display: "flex",
    alignItems: "center",
    cursor: "pointer",
    borderRadius: 2,
    width: 120,
    marginBottom: theme.spacing.unit
  },
  hideMap: {
    width: 34,
    padding: 5
  },
  buttonText: {
    marginLeft: 10,
    fontWeight: 500,
    fontFamily: "Roboto",
  },
  mapButtons: {
    alignItems: "flex-end",
    position: "absolute",
    top: isFriendlyUI ? 40 : 10,
    right: 10,
    display: "flex",
    flexDirection: "column",
    [theme.breakpoints.down('md')]: {
      top: 24
    }
  },
  filters: {
    width: 100
  }
}));



// Make these variables have file-scope references to avoid rerending the scripts or map
export const defaultCenter = {lat: 39.5, lng: -43.636047}
const CommunityMap = ({ groupTerms, eventTerms, keywordSearch, initialOpenWindows = [], center = defaultCenter, zoom = 2, classes, className = '', showGroupsByDefault, showUsersByDefault, showHideMap = false, hideLegend, petrovButton }: {
  groupTerms: LocalgroupsViewTerms,
  eventTerms?: PostsViewTerms,
  keywordSearch?: string,
  initialOpenWindows: Array<string>,
  center?: {lat: number, lng: number},
  zoom: number,
  classes: ClassesType,
  className?: string,
  showUsersByDefault?: boolean,
  showGroupsByDefault?: boolean,
  showHideMap?: boolean,
  hideLegend?: boolean,
  petrovButton?: boolean,
}) => {
  const { query } = useLocation()
  const groupQueryTerms: LocalgroupsViewTerms = groupTerms || {view: "all", filters: query?.filters || [], includeInactive: query?.includeInactive === 'true'}

  const [ openWindows, setOpenWindows ] = useState(initialOpenWindows)
  const handleClick = useCallback(
    (id: string) => { setOpenWindows([id]) }
    , []
  )
  const handleClose = useCallback(
    (id: string) => { setOpenWindows(_.without(openWindows, id))}
    , [openWindows]
  )

  const [ showEvents, setShowEvents ] = useState(true)
  const [ showGroups, setShowGroups ] = useState(!!showGroupsByDefault)
  const [ showUsers, setShowUsers ] = useState(!!showUsersByDefault)
  const [ showMap, setShowMap ] = useState(true)

  const [ viewport, setViewport ] = useState({
    latitude: center.lat,
    longitude: center.lng,
    zoom: zoom
  })
  
  // when getting the location from the browser, we want to re-center the map
  useEffect(() => {
    setViewport({
      latitude: center.lat,
      longitude: center.lng,
      zoom: zoom
    })
  }, [center.lat, center.lng, zoom])

  const { results: events = [] } = useMulti({
    terms: eventTerms || {view: 'events'},
    collectionName: "Posts",
    fragmentName: "PostsList",
    limit: 500,
    skip: !eventTerms
  });

  const {results: groupsPostgres} = useMulti({
    terms: groupQueryTerms,
    collectionName: "Localgroups",
    fragmentName: "localGroupsHomeFragment",
    limit: 500,
    skip: !showGroups || isFriendlyUI,
  })
  const {results: groupsElastic} = useSearch<SearchLocalgroup>({
    indexName: "localgroups",
    query: "",
    page: 0,
    hitsPerPage: 500,
    skip: !showGroups || !isFriendlyUI,
  });
  const groups: (localGroupsHomeFragment|SearchLocalgroup)[] =
    (isFriendlyUI ? groupsElastic : groupsPostgres) ?? [];

  // filter the list of groups if the user has typed in a keyword
  let visibleGroups = groups
  if (keywordSearch) {
    visibleGroups = groups.filter(group => (
      `${group.name.toLowerCase()} ${group.location?.toLowerCase()}`.includes(keywordSearch.toLowerCase())
    ))
  }

  const { results: users = [] } = useMulti({
    terms: {view: "usersMapLocations"},
    collectionName: "Users",
    fragmentName: "UsersMapEntry",
    limit: 500,
    skip: !showUsers
  })

  const renderedMarkers = useMemo(() => {
    return <React.Fragment>
      {showEvents && <LocalEventsMapMarkers events={events} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}
      {showGroups && <LocalGroupsMapMarkers groups={visibleGroups} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}
      {showUsers && <Components.PersonalMapLocationMarkers users={users} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}
      {!hideLegend && <div className={classes.mapButtons}>
        <Components.CommunityMapFilter 
          showHideMap={showHideMap} 
          toggleEvents={() => setShowEvents(!showEvents)} showEvents={showEvents}
          toggleGroups={() => setShowGroups(!showGroups)} showGroups={showGroups}
          toggleIndividuals={() => setShowUsers(!showUsers)} 
          showIndividuals={showUsers}
          setShowMap={setShowMap}
        />
      </div>}
    </React.Fragment>
  }, [showEvents, events, handleClick, handleClose, openWindows, showGroups, visibleGroups, showUsers, users, classes.mapButtons, showHideMap, hideLegend])

  if (!showMap) return null

  return <div className={classNames(classes.root, {[className]: className})}>
      <Helmet> 
        <link href='https://api.tiles.mapbox.com/mapbox-gl-js/v1.3.1/mapbox-gl.css' rel='stylesheet' />
      </Helmet>
      <ReactMapGL
        {...viewport}
        width="100%"
        height="100%"
        mapStyle={isFriendlyUI ? undefined : "mapbox://styles/habryka/cilory317001r9mkmkcnvp2ra"}
        onViewportChange={viewport => setViewport(viewport)}
        mapboxApiAccessToken={mapboxAPIKeySetting.get() || undefined}
      >
        {renderedMarkers}
      </ReactMapGL>
      {/*{petrovButton && <Components.PetrovDayButton />}*/}
  </div>
}

const personalMapMarkerStyles = (theme: ThemeType): JssStyles => ({
  icon: {
    height: 20,
    width: 20,
    fill: theme.palette.individual,
    opacity: 0.8
  }
})
const PersonalMapLocationMarkers = ({users, handleClick, handleClose, openWindows, classes}: {
  users: Array<UsersMapEntry>,
  handleClick: (userId: string) => void,
  handleClose: (userId: string) => void,
  openWindows: any,
  classes: ClassesType,
}) => {
  const { StyledMapPopup } = Components
  
  const mapLocations = filterNonnull(users.map(user => {
    const location = user.mapLocation
    if (!location?.geometry?.location?.lat || !location?.geometry?.location?.lng) return null
    const { geometry: {location: {lat, lng}}} = location
    return {
      lat, lng,
      data: user,
    }
  }));
  
  const spreadMapLocations = spreadMapMarkers(mapLocations, u=>u.displayName);
  
  return <React.Fragment>
    {spreadMapLocations.map(({lat, lng, data: user}) => {
      const htmlBody = {__html: user.htmlMapMarkerText};
      return <React.Fragment key={user._id}>
        <Marker
          latitude={lat}
          longitude={lng}
          offsetLeft={-8}
          offsetTop={-20}
        >
          <span onClick={() => handleClick(user._id)}>
            <PersonIcon className={classes.icon}/>
          </span>
        </Marker>
        {openWindows.includes(user._id) && 
          <StyledMapPopup
            lat={lat}
            lng={lng}
            link={userGetProfileUrl(user)}
            title={` [User] ${userGetDisplayName(user)} `}
            onClose={() => handleClose(user._id)}
          >
            <div dangerouslySetInnerHTML={htmlBody} />
          </StyledMapPopup>}
      </React.Fragment>
    })}
  </React.Fragment>
}
const PersonalMapLocationMarkersTypes = registerComponent("PersonalMapLocationMarkers", PersonalMapLocationMarkers, {
  styles: personalMapMarkerStyles
});

const LocalEventsMapMarkers = ({events, handleClick, handleClose, openWindows}: {
  events: Array<PostsList>,
  handleClick: (eventId: string) => void,
  handleClose: (eventId: string) => void,
  openWindows: any,
}) => {
  return <>{events.map((event) => {
    return <Components.LocalEventMarker
      key={event._id}
      event={event}
      handleMarkerClick={handleClick}
      handleInfoWindowClose={handleClose}
      infoOpen={openWindows.includes(event._id)}
      location={event.googleLocation}
    />
  })}</>
}

const LocalGroupsMapMarkers = ({groups, handleClick, handleClose, openWindows}: {
  groups: Array<localGroupsHomeFragment|SearchLocalgroup>,
  handleClick: (eventId: string) => void,
  handleClose: (eventId: string) => void,
  openWindows: any,
}) => {
  return <>{groups.map((group) => {
    const location = "googleLocation" in group
      ? {
        lng: group.googleLocation?.geometry?.location?.lng,
        lat: group.googleLocation?.geometry?.location?.lat,
      }
      : {
        lng: group._geoloc?.coordinates?.[0],
        lat: group._geoloc?.coordinates?.[1],
      };
    return(
      <Components.LocalGroupMarker
        key={group._id}
        group={group}
        handleMarkerClick={handleClick}
        handleInfoWindowClose={handleClose}
        infoOpen={openWindows.includes(group._id)}
        location={location}
      />
    )
  })}</>
}



const CommunityMapComponent = registerComponent("CommunityMap", CommunityMap, { styles });

declare global {
  interface ComponentTypes {
    CommunityMap: typeof CommunityMapComponent
    PersonalMapLocationMarkers: typeof PersonalMapLocationMarkersTypes
  }
}

1	import React, { useState, useCallback, useMemo, useEffect } from 'react';	3✔
2	import { Components, registerComponent } from '../../lib/vulcan-lib';	1✔
3	import { useMulti } from '../../lib/crud/withMulti';	1✔
4	import { createStyles } from '@material-ui/core/styles';	1✔
5	import { userGetDisplayName, userGetProfileUrl } from '../../lib/collections/users/helpers';	1✔
6	import { useLocation } from '../../lib/routeUtil';	1✔
7	import BadlyTypedReactMapGL, { Marker as BadlyTypedMarker } from 'react-map-gl';	1✔
8	import * as _ from 'underscore';	1✔
9	import { mapboxAPIKeySetting } from '../../lib/publicSettings';	1✔
10	import PersonIcon from '@material-ui/icons/Person';	1✔
11	import classNames from 'classnames';	1✔
12	import { componentWithChildren, Helmet } from '../../lib/utils/componentsWithChildren';	1✔
13	import {isFriendlyUI} from '../../themes/forumTheme'	1✔
14	import { filterNonnull } from '../../lib/utils/typeGuardUtils';	1✔
15	import { spreadMapMarkers } from '../../lib/utils/spreadMapMarkers';	1✔
16	import { useSearch } from '../../lib/search/searchUtil';	1✔
17
18	const ReactMapGL = componentWithChildren(BadlyTypedReactMapGL);	1✔
19	const Marker = componentWithChildren(BadlyTypedMarker);	1✔
20
21	const styles = createStyles((theme: ThemeType): JssStyles => ({	1✔
22	root: {
23	width: "100%",
24	height: 440,
25	// We give this a negative margin to make sure that the map is flush with the top
26	marginTop: -50,
27	[theme.breakpoints.down('sm')]: {
28	marginTop: 0,
29	marginLeft: -8
30	},
31	position: "relative",
32	boxShadow: theme.palette.boxShadow.default,
33
34	"& .mapboxgl-popup-content": {
35	background: theme.palette.panelBackground.default,
36	},
37	"& .StyledMapPopup-markerPageLink": {
38	color: theme.palette.text.normal,
39	},
40	},
41	communityMap: {},
42	mapButton: {
43	padding: 10,
44	display: "flex",
45	alignItems: "center",
46	cursor: "pointer",
47	borderRadius: 2,
48	width: 120,
49	marginBottom: theme.spacing.unit
50	},
51	hideMap: {
52	width: 34,
53	padding: 5
54	},
55	buttonText: {
56	marginLeft: 10,
57	fontWeight: 500,
58	fontFamily: "Roboto",
59	},
60	mapButtons: {
61	alignItems: "flex-end",
62	position: "absolute",
63	top: isFriendlyUI ? 40 : 10,	1!
64	right: 10,
65	display: "flex",
66	flexDirection: "column",
67	[theme.breakpoints.down('md')]: {
68	top: 24
69	}
70	},
71	filters: {
72	width: 100
73	}
74	}));
75
76
77
78	// Make these variables have file-scope references to avoid rerending the scripts or map
79	export const defaultCenter = {lat: 39.5, lng: -43.636047}	1✔
80	const CommunityMap = ({ groupTerms, eventTerms, keywordSearch, initialOpenWindows = [], center = defaultCenter, zoom = 2, classes, className = '', showGroupsByDefault, showUsersByDefault, showHideMap = false, hideLegend, petrovButton }: {	1!
81	groupTerms: LocalgroupsViewTerms,
82	eventTerms?: PostsViewTerms,
83	keywordSearch?: string,
84	initialOpenWindows: Array<string>,
85	center?: {lat: number, lng: number},
86	zoom: number,
87	classes: ClassesType,
88	className?: string,
89	showUsersByDefault?: boolean,
90	showGroupsByDefault?: boolean,
91	showHideMap?: boolean,
92	hideLegend?: boolean,
93	petrovButton?: boolean,
94	}) => {
95	const { query } = useLocation()	×
96	const groupQueryTerms: LocalgroupsViewTerms = groupTerms \|\| {view: "all", filters: query?.filters \|\| [], includeInactive: query?.includeInactive === 'true'}	×
97
98	const [ openWindows, setOpenWindows ] = useState(initialOpenWindows)	×
99	const handleClick = useCallback(	×
100	(id: string) => { setOpenWindows([id]) }	×
101	, []
102	)
103	const handleClose = useCallback(	×
104	(id: string) => { setOpenWindows(_.without(openWindows, id))}	×
105	, [openWindows]
106	)
107
108	const [ showEvents, setShowEvents ] = useState(true)	×
109	const [ showGroups, setShowGroups ] = useState(!!showGroupsByDefault)	×
110	const [ showUsers, setShowUsers ] = useState(!!showUsersByDefault)	×
111	const [ showMap, setShowMap ] = useState(true)	×
112
113	const [ viewport, setViewport ] = useState({	×
114	latitude: center.lat,
115	longitude: center.lng,
116	zoom: zoom
117	})
118
119	// when getting the location from the browser, we want to re-center the map
120	useEffect(() => {	×
121	setViewport({	×
122	latitude: center.lat,
123	longitude: center.lng,
124	zoom: zoom
125	})
126	}, [center.lat, center.lng, zoom])
127
128	const { results: events = [] } = useMulti({	×
129	terms: eventTerms \|\| {view: 'events'},	×
130	collectionName: "Posts",
131	fragmentName: "PostsList",
132	limit: 500,
133	skip: !eventTerms
134	});
135
NEW 136	const {results: groupsPostgres} = useMulti({	×
137	terms: groupQueryTerms,
138	collectionName: "Localgroups",
139	fragmentName: "localGroupsHomeFragment",
140	limit: 500,
141	skip: !showGroups \|\| isFriendlyUI,	×
142	})
NEW 143	const {results: groupsElastic} = useSearch<SearchLocalgroup>({	×
144	indexName: "localgroups",
145	query: "",
146	page: 0,
147	hitsPerPage: 500,
148	skip: !showGroups \|\| !isFriendlyUI,	×
149	});
NEW 150	const groups: (localGroupsHomeFragment\|SearchLocalgroup)[] =	×
151	(isFriendlyUI ? groupsElastic : groupsPostgres) ?? [];	×
152
153	// filter the list of groups if the user has typed in a keyword
154	let visibleGroups = groups	×
155	if (keywordSearch) {	×
156	visibleGroups = groups.filter(group => (	×
157	`${group.name.toLowerCase()} ${group.location?.toLowerCase()}`.includes(keywordSearch.toLowerCase())	×
158	))
159	}
160
161	const { results: users = [] } = useMulti({	×
162	terms: {view: "usersMapLocations"},
163	collectionName: "Users",
164	fragmentName: "UsersMapEntry",
165	limit: 500,
166	skip: !showUsers
167	})
168
169	const renderedMarkers = useMemo(() => {	×
UNCOV 170	return <React.Fragment>	×
171	{showEvents && <LocalEventsMapMarkers events={events} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}	×
172	{showGroups && <LocalGroupsMapMarkers groups={visibleGroups} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}	×
173	{showUsers && <Components.PersonalMapLocationMarkers users={users} handleClick={handleClick} handleClose={handleClose} openWindows={openWindows} />}	×
174	{!hideLegend && <div className={classes.mapButtons}>	×
175	<Components.CommunityMapFilter
176	showHideMap={showHideMap}
177	toggleEvents={() => setShowEvents(!showEvents)} showEvents={showEvents}	×
178	toggleGroups={() => setShowGroups(!showGroups)} showGroups={showGroups}	×
179	toggleIndividuals={() => setShowUsers(!showUsers)}	×
180	showIndividuals={showUsers}
181	setShowMap={setShowMap}
182	/>
183	</div>}
184	</React.Fragment>
185	}, [showEvents, events, handleClick, handleClose, openWindows, showGroups, visibleGroups, showUsers, users, classes.mapButtons, showHideMap, hideLegend])
186
187	if (!showMap) return null	×
188
189	return <div className={classNames(classes.root, {[className]: className})}>	×
190	<Helmet>
191	<link href='https://api.tiles.mapbox.com/mapbox-gl-js/v1.3.1/mapbox-gl.css' rel='stylesheet' />
192	</Helmet>
193	<ReactMapGL
194	{...viewport}
195	width="100%"
196	height="100%"
197	mapStyle={isFriendlyUI ? undefined : "mapbox://styles/habryka/cilory317001r9mkmkcnvp2ra"}	×
198	onViewportChange={viewport => setViewport(viewport)}	×
199	mapboxApiAccessToken={mapboxAPIKeySetting.get() \|\| undefined}	×
200	>
201	{renderedMarkers}
202	</ReactMapGL>
203	{/{petrovButton && <Components.PetrovDayButton />}/}
204	</div>
205	}
206
207	const personalMapMarkerStyles = (theme: ThemeType): JssStyles => ({	1✔
208	icon: {
209	height: 20,
210	width: 20,
211	fill: theme.palette.individual,
212	opacity: 0.8
213	}
214	})
215	const PersonalMapLocationMarkers = ({users, handleClick, handleClose, openWindows, classes}: {	1✔
216	users: Array<UsersMapEntry>,
217	handleClick: (userId: string) => void,
218	handleClose: (userId: string) => void,
219	openWindows: any,
220	classes: ClassesType,
221	}) => {
222	const { StyledMapPopup } = Components	×
223
224	const mapLocations = filterNonnull(users.map(user => {	×
225	const location = user.mapLocation	×
226	if (!location?.geometry?.location?.lat \|\| !location?.geometry?.location?.lng) return null	×
227	const { geometry: {location: {lat, lng}}} = location	×
228	return {	×
229	lat, lng,
230	data: user,
231	}
232	}));
233
234	const spreadMapLocations = spreadMapMarkers(mapLocations, u=>u.displayName);	×
235
236	return <React.Fragment>	×
237	{spreadMapLocations.map(({lat, lng, data: user}) => {
238	const htmlBody = {__html: user.htmlMapMarkerText};	×
239	return <React.Fragment key={user._id}>	×
240	<Marker
241	latitude={lat}
242	longitude={lng}
243	offsetLeft={-8}
244	offsetTop={-20}
245	>
246	<span onClick={() => handleClick(user._id)}>	×
247	<PersonIcon className={classes.icon}/>
248	</span>
249	</Marker>
250	{openWindows.includes(user._id) &&	×
251	<StyledMapPopup
252	lat={lat}
253	lng={lng}
254	link={userGetProfileUrl(user)}
255	title={` [User] ${userGetDisplayName(user)} `}
256	onClose={() => handleClose(user._id)}	×
257	>
258	<div dangerouslySetInnerHTML={htmlBody} />
259	</StyledMapPopup>}
260	</React.Fragment>
261	})}
262	</React.Fragment>
263	}
264	const PersonalMapLocationMarkersTypes = registerComponent("PersonalMapLocationMarkers", PersonalMapLocationMarkers, {	1✔
265	styles: personalMapMarkerStyles
266	});
267
268	const LocalEventsMapMarkers = ({events, handleClick, handleClose, openWindows}: {	1✔
269	events: Array<PostsList>,
270	handleClick: (eventId: string) => void,
271	handleClose: (eventId: string) => void,
272	openWindows: any,
273	}) => {
274	return <>{events.map((event) => {	×
275	return <Components.LocalEventMarker	×
276	key={event._id}
277	event={event}
278	handleMarkerClick={handleClick}
279	handleInfoWindowClose={handleClose}
280	infoOpen={openWindows.includes(event._id)}
281	location={event.googleLocation}
282	/>
283	})}</>
284	}
285
286	const LocalGroupsMapMarkers = ({groups, handleClick, handleClose, openWindows}: {	1✔
287	groups: Array<localGroupsHomeFragment\|SearchLocalgroup>,
288	handleClick: (eventId: string) => void,
289	handleClose: (eventId: string) => void,
290	openWindows: any,
291	}) => {
292	return <>{groups.map((group) => {	×
NEW 293	const location = "googleLocation" in group	×
294	? {	×
295	lng: group.googleLocation?.geometry?.location?.lng,	×
296	lat: group.googleLocation?.geometry?.location?.lat,	×
297	}
298	: {
299	lng: group._geoloc?.coordinates?.[0],	×
300	lat: group._geoloc?.coordinates?.[1],	×
301	};
UNCOV 302	return(	×
303	<Components.LocalGroupMarker
304	key={group._id}
305	group={group}
306	handleMarkerClick={handleClick}
307	handleInfoWindowClose={handleClose}
308	infoOpen={openWindows.includes(group._id)}
309	location={location}
310	/>
311	)
312	})}</>
313	}
314
315
316
317	const CommunityMapComponent = registerComponent("CommunityMap", CommunityMap, { styles });	1✔
318
319	declare global {
320	interface ComponentTypes {
321	CommunityMap: typeof CommunityMapComponent
322	PersonalMapLocationMarkers: typeof PersonalMapLocationMarkersTypes
323	}
324	}

ForumMagnum / ForumMagnum / 8741035643

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