18451009991

Committed 12 Oct 2025 11:29PM UTC coverage: 43.532% (-19.9%) from 63.458%

Build # 18451009991

Build Type

Pull #475

github

Committed by

web-flow

Commit Message

Merge 9d0374e51 into 0a0ddf96f

Pull Request Pull Request #475: pretty permalinks

Run Details

369 of 1009 branches covered (36.57%)

Branch coverage included in aggregate %.

15 of 37 new or added lines in 5 files covered. (40.54%)

236 existing lines in 17 files now uncovered.

553 of 1109 relevant lines covered (49.86%)

4.31 hits per line

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

3.85

/src/hooks/data.tsx

import {
  createContext,
  PropsWithChildren,
  useContext,
  useEffect,
  useState,
} from 'react';

import {
  getDistance,
  isGoogleSheetData,
  loadMeetingData,
  translateGoogleSheet,
} from '../helpers';
import { Index, JSONData, Meeting } from '../types';
import { useError } from './error';
import { useInput } from './input';
import { useSettings } from './settings';

export type Data = {
  capabilities: {
    coordinates: boolean;
    distance: boolean;
    geolocation: boolean;
    inactive: boolean;
    location: boolean;
    region: boolean;
    sharing: boolean;
    time: boolean;
    type: boolean;
    weekday: boolean;
  };
  indexes: {
    distance: Index[];
    region: Index[];
    time: Index[];
    type: Index[];
    weekday: Index[];
  };
  meetings: { [index: string]: Meeting };
  slugs: string[];
  waitingForData: boolean;
};

const defaultData: Data = {
  capabilities: {
    coordinates: false,
    distance: false,
    geolocation: false,
    inactive: false,
    location: false,
    region: false,
    sharing: false,
    time: false,
    type: false,
    weekday: false,
  },
  indexes: {
    distance: [],
    region: [],
    time: [],
    type: [],
    weekday: [],
  },
  meetings: {},
  slugs: [],
  waitingForData: true,
};

const DataContext = createContext<Data>(defaultData);

export const useData = () => useContext(DataContext);

export const DataProvider = ({
  children,
  google,
  src,
  timezone,
}: PropsWithChildren<{ google?: string; src?: string; timezone?: string }>) => {
  const [data, setData] = useState<Data>(defaultData);
  const { setError } = useError();
  const { input, latitude, longitude, setBounds } = useInput();
  const { settings, strings } = useSettings();

  useEffect(() => {
    if (timezone) {
      try {
        // check if timezone is valid
        Intl.DateTimeFormat(undefined, { timeZone: timezone });
      } catch (e) {
        throw new Error(
          `Timezone ${timezone} is not valid. Please use one like America/New_York.`
        );
      }
    }

    const sources = src?.split(',').filter(Boolean) || [];

    if (!sources.length) {
      throw new Error('a data source must be specified');
    }

    const sheets: (string | undefined)[] = [];

    Promise.all(
      sources.map(src => {
        const sheetId = src.startsWith(
          'https://docs.google.com/spreadsheets/d/'
        )
          ? src.split('/')[5]
          : undefined;
        sheets.push(sheetId);

        // google sheet
        if (sheetId) {
          if (!google) {
            throw new Error('a Google API key is required');
          }
          src = `https://sheets.googleapis.com/v4/spreadsheets/${sheetId}/values/A1:ZZ?key=${google}`;
        }

        // cache busting
        if (src.endsWith('.json') && input.meeting) {
          src = `${src}?${new Date().getTime()}`;
        }

        return fetch(src);
      })
    )
      .then(responses =>
        Promise.all(
          responses.map(res =>
            res.ok ? res.json() : Promise.reject(res.status)
          )
        )
      )
      .then((responses: JSONData[][]) => {
        const json = responses
          .map((json, index) => {
            const sheetId = sheets[index];
            return isGoogleSheetData(json) && sheetId
              ? translateGoogleSheet(json, sheetId, settings)
              : json;
          })
          .flat();

        if (!Array.isArray(json) || !json.length) {
          throw new Error('data is not in the correct format');
        }

        const { bounds, capabilities, indexes, meetings, slugs } =
          loadMeetingData(json, data.capabilities, settings, strings, timezone);

        if (!timezone && !slugs.length) {
          throw new Error('time zone is not set');
        }

        if (bounds) {
          setBounds(bounds);
        }

        setData({
          capabilities,
          indexes,
          meetings,
          slugs,
          waitingForData: false,
        });
      })
      .catch(error => {
        setError(`Loading error: ${error}`);
        setData(prevData => ({ ...prevData, waitingForData: false }));
      });
  }, []);

  // calculate distance if coordinates are available
  useEffect(() => {
    if (!latitude || !longitude || !data.meetings || data.waitingForData) {
      return;
    }

    const distances = Object.fromEntries(
      settings.distance_options.map(option => [option, []])
    );

    Object.keys(data.meetings).forEach(slug => {
      const meeting = data.meetings[slug];
      if (meeting.latitude && meeting.longitude) {
        meeting.distance = getDistance(
          { latitude, longitude },
          meeting,
          settings
        );
      }

      for (const option of settings.distance_options) {
        if (meeting.distance && meeting.distance <= option) {
          (distances[option] as string[]).push(meeting.slug);
        }
      }

      data.meetings[slug] = meeting;
    });

    const distance: Index[] = Object.entries(distances).map(([key, slugs]) => ({
      key,
      name: `${key} ${settings.distance_unit}`,
      slugs,
    }));

    setData(prevData => ({
      ...prevData,
      capabilities: {
        ...prevData.capabilities,
        distance: true,
      },
      indexes: {
        ...prevData.indexes,
        distance,
      },
      meetings: data.meetings,
    }));
  }, [latitude, longitude, data.meetings, settings.distance_unit]);

  return <DataContext.Provider value={data}>{children}</DataContext.Provider>;
};

1	import {
2	createContext,
3	PropsWithChildren,
4	useContext,
5	useEffect,
6	useState,
7	} from 'react';
8
9	import {
10	getDistance,
11	isGoogleSheetData,
12	loadMeetingData,
13	translateGoogleSheet,
14	} from '../helpers';
15	import { Index, JSONData, Meeting } from '../types';
16	import { useError } from './error';
17	import { useInput } from './input';
18	import { useSettings } from './settings';
19
20	export type Data = {
21	capabilities: {
22	coordinates: boolean;
23	distance: boolean;
24	geolocation: boolean;
25	inactive: boolean;
26	location: boolean;
27	region: boolean;
28	sharing: boolean;
29	time: boolean;
30	type: boolean;
31	weekday: boolean;
32	};
33	indexes: {
34	distance: Index[];
35	region: Index[];
36	time: Index[];
37	type: Index[];
38	weekday: Index[];
39	};
40	meetings: { [index: string]: Meeting };
41	slugs: string[];
42	waitingForData: boolean;
43	};
44
45	const defaultData: Data = {	8✔
46	capabilities: {
47	coordinates: false,
48	distance: false,
49	geolocation: false,
50	inactive: false,
51	location: false,
52	region: false,
53	sharing: false,
54	time: false,
55	type: false,
56	weekday: false,
57	},
58	indexes: {
59	distance: [],
60	region: [],
61	time: [],
62	type: [],
63	weekday: [],
64	},
65	meetings: {},
66	slugs: [],
67	waitingForData: true,
68	};
69
70	const DataContext = createContext<Data>(defaultData);	8✔
71
72	export const useData = () => useContext(DataContext);	8✔
73
74	export const DataProvider = ({	8✔
75	children,
76	google,
77	src,
78	timezone,
79	}: PropsWithChildren<{ google?: string; src?: string; timezone?: string }>) => {
UNCOV 80	const [data, setData] = useState<Data>(defaultData);	×
UNCOV 81	const { setError } = useError();	×
UNCOV 82	const { input, latitude, longitude, setBounds } = useInput();	×
UNCOV 83	const { settings, strings } = useSettings();	×
84
UNCOV 85	useEffect(() => {	×
UNCOV 86	if (timezone) {	×
87	try {	×
88	// check if timezone is valid
89	Intl.DateTimeFormat(undefined, { timeZone: timezone });	×
90	} catch (e) {
91	throw new Error(	×
92	`Timezone ${timezone} is not valid. Please use one like America/New_York.`
93	);
94	}
95	}
96
UNCOV 97	const sources = src?.split(',').filter(Boolean) \|\| [];	×
98
UNCOV 99	if (!sources.length) {	×
100	throw new Error('a data source must be specified');	×
101	}
102
UNCOV 103	const sheets: (string \| undefined)[] = [];	×
104
UNCOV 105	Promise.all(	×
106	sources.map(src => {
UNCOV 107	const sheetId = src.startsWith(	×
108	'https://docs.google.com/spreadsheets/d/'
109	)
110	? src.split('/')[5]
111	: undefined;
UNCOV 112	sheets.push(sheetId);	×
113
114	// google sheet
UNCOV 115	if (sheetId) {	×
116	if (!google) {	×
117	throw new Error('a Google API key is required');	×
118	}
119	src = `https://sheets.googleapis.com/v4/spreadsheets/${sheetId}/values/A1:ZZ?key=${google}`;	×
120	}
121
122	// cache busting
UNCOV 123	if (src.endsWith('.json') && input.meeting) {	×
124	src = `${src}?${new Date().getTime()}`;	×
125	}
126
UNCOV 127	return fetch(src);	×
128	})
129	)
130	.then(responses =>
UNCOV 131	Promise.all(	×
132	responses.map(res =>
UNCOV 133	res.ok ? res.json() : Promise.reject(res.status)	×
134	)
135	)
136	)
137	.then((responses: JSONData[][]) => {
UNCOV 138	const json = responses	×
139	.map((json, index) => {
UNCOV 140	const sheetId = sheets[index];	×
UNCOV 141	return isGoogleSheetData(json) && sheetId	×
142	? translateGoogleSheet(json, sheetId, settings)
143	: json;
144	})
145	.flat();
146
UNCOV 147	if (!Array.isArray(json) \|\| !json.length) {	×
148	throw new Error('data is not in the correct format');	×
149	}
150
151	const { bounds, capabilities, indexes, meetings, slugs } =
UNCOV 152	loadMeetingData(json, data.capabilities, settings, strings, timezone);	×
153
UNCOV 154	if (!timezone && !slugs.length) {	×
155	throw new Error('time zone is not set');	×
156	}
157
UNCOV 158	if (bounds) {	×
159	setBounds(bounds);	×
160	}
161
UNCOV 162	setData({	×
163	capabilities,
164	indexes,
165	meetings,
166	slugs,
167	waitingForData: false,
168	});
169	})
170	.catch(error => {
171	setError(`Loading error: ${error}`);	×
172	setData(prevData => ({ ...prevData, waitingForData: false }));	×
173	});
174	}, []);
175
176	// calculate distance if coordinates are available
UNCOV 177	useEffect(() => {	×
UNCOV 178	if (!latitude \|\| !longitude \|\| !data.meetings \|\| data.waitingForData) {	×
UNCOV 179	return;	×
180	}
181
182	const distances = Object.fromEntries(	×
183	settings.distance_options.map(option => [option, []])	×
184	);
185
186	Object.keys(data.meetings).forEach(slug => {	×
187	const meeting = data.meetings[slug];	×
188	if (meeting.latitude && meeting.longitude) {	×
189	meeting.distance = getDistance(	×
190	{ latitude, longitude },
191	meeting,
192	settings
193	);
194	}
195
196	for (const option of settings.distance_options) {	×
197	if (meeting.distance && meeting.distance <= option) {	×
198	(distances[option] as string[]).push(meeting.slug);	×
199	}
200	}
201
202	data.meetings[slug] = meeting;	×
203	});
204
205	const distance: Index[] = Object.entries(distances).map(([key, slugs]) => ({	×
206	key,
207	name: `${key} ${settings.distance_unit}`,
208	slugs,
209	}));
210
211	setData(prevData => ({	×
212	...prevData,
213	capabilities: {
214	...prevData.capabilities,
215	distance: true,
216	},
217	indexes: {
218	...prevData.indexes,
219	distance,
220	},
221	meetings: data.meetings,
222	}));
223	}, [latitude, longitude, data.meetings, settings.distance_unit]);
224
UNCOV 225	return <DataContext.Provider value={data}>{children}</DataContext.Provider>;	×
226	};

code4recovery / tsml-ui / 18451009991

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