mirror of
https://github.com/TheRealOwenRees/echecsfrance.git
synced 2026-11-18 07:22:06 +00:00
replace cancel button with X use search params instead of path fix routes for filtering clubs by URL, add loading map spinner, remove useEffect normalised region name in url will set filter search region by url params add i8n to region filtering use jotai useSetAtom select value becomes the name of the region on selection fix geojson types fix region names apply same regional filtering logic to tournaments that we have for clubs type fixes for GeoJson Feature basic filtering of clubs by region working remove comments two column layout change text colours accept undefined in region data state selecting a region from modal sets state with region data of Feature type. Types currently not all correct. by region filter satisfies types, with no functionality yet remove unused imports add region option in dropdown rename file to reflect its function json file for region names comment out analytics script for testing loading upgrade mongo unformat file to keep line count small add json of French regions coordinates upgrade next to last v14
231 lines
6.4 KiB
TypeScript
231 lines
6.4 KiB
TypeScript
import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
|
|
import {
|
|
endOfDay,
|
|
isAfter,
|
|
isBefore,
|
|
parse,
|
|
setDefaultOptions,
|
|
startOfDay,
|
|
} from "date-fns";
|
|
import { fr } from "date-fns/locale";
|
|
import {
|
|
Feature,
|
|
FeatureCollection,
|
|
GeoJsonProperties,
|
|
MultiPolygon,
|
|
Polygon,
|
|
} from "geojson";
|
|
import { atom } from "jotai";
|
|
import { LatLngBounds } from "leaflet";
|
|
|
|
import { Club, TimeControl, Tournament } from "@/types";
|
|
import atomWithDebounce from "@/utils/atomWithDebounce";
|
|
import { normalizedContains } from "@/utils/string";
|
|
|
|
setDefaultOptions({ locale: fr });
|
|
|
|
type RegionFilter =
|
|
| "all"
|
|
| "map"
|
|
| "region"
|
|
| Feature<Polygon | MultiPolygon, GeoJsonProperties>
|
|
| {
|
|
id: string;
|
|
name: string;
|
|
features: FeatureCollection;
|
|
};
|
|
|
|
export function isFeature(obj: any): obj is Feature {
|
|
return (
|
|
obj &&
|
|
typeof obj === "object" &&
|
|
obj.type === "Feature" &&
|
|
obj.properties !== undefined &&
|
|
obj.geometry !== undefined &&
|
|
(obj.geometry.type === "Polygon" || obj.geometry.type === "MultiPolygon")
|
|
);
|
|
}
|
|
|
|
export const burgerMenuIsOpenAtom = atom(false);
|
|
export const mapBoundsAtom = atom<LatLngBounds | null>(null);
|
|
export const regionFilterAtom = atom<RegionFilter>("map");
|
|
export const searchStringAtom = atom("");
|
|
|
|
export const tournamentsAtom = atom<Tournament[]>([]);
|
|
export const normsOnlyAtom = atom(false);
|
|
|
|
export const classicAtom = atom(true);
|
|
export const rapidAtom = atom(true);
|
|
export const blitzAtom = atom(true);
|
|
export const otherAtom = atom(true);
|
|
|
|
export const clubsAtom = atom<Club[]>([]);
|
|
|
|
export const {
|
|
currentValueAtom: hoveredMapIdAtom,
|
|
debouncedValueAtom: debouncedHoveredMapIdAtom,
|
|
} = atomWithDebounce<string | null>(null);
|
|
|
|
export const { debouncedValueAtom: debouncedHoveredListIdAtom } =
|
|
atomWithDebounce<string | null>(null, 1000, 100);
|
|
|
|
export const filteredTournamentsByTimeControlAndZoneAtom = atom((get) => {
|
|
const tournaments = get(tournamentsAtom);
|
|
const regionFilter = get(regionFilterAtom);
|
|
|
|
const classic = get(classicAtom);
|
|
const rapid = get(rapidAtom);
|
|
const blitz = get(blitzAtom);
|
|
const other = get(otherAtom);
|
|
|
|
const dateRange = get(dateRangeAtom);
|
|
const { startDate, endDate } = dateRange[0];
|
|
|
|
const filterByTimeControl = tournaments.filter((tournament) => {
|
|
const tournamentDate = startOfDay(
|
|
parse(tournament.date, "dd/MM/yyyy", new Date()),
|
|
);
|
|
|
|
return (
|
|
!isBefore(tournamentDate, startDate) &&
|
|
(endDate === undefined || !isAfter(tournamentDate, endDate)) &&
|
|
!tournament.pending &&
|
|
tournament.status === "scheduled" &&
|
|
((tournament.timeControl === TimeControl.Classic && classic) ||
|
|
(tournament.timeControl === TimeControl.Rapid && rapid) ||
|
|
(tournament.timeControl === TimeControl.Blitz && blitz) ||
|
|
(tournament.timeControl === TimeControl.Other && other))
|
|
);
|
|
});
|
|
|
|
if (
|
|
regionFilter === "all" ||
|
|
regionFilter === "map" ||
|
|
regionFilter === "region"
|
|
)
|
|
return filterByTimeControl;
|
|
|
|
if (isFeature(regionFilter)) {
|
|
return filterByTimeControl.filter((tournament) => {
|
|
return booleanPointInPolygon(
|
|
[tournament.latLng.lng, tournament.latLng.lat],
|
|
regionFilter.geometry,
|
|
);
|
|
});
|
|
}
|
|
|
|
return filterByTimeControl.filter((tournament) => {
|
|
return regionFilter.features?.features?.some(
|
|
(feature) =>
|
|
feature.geometry.type === "Polygon" &&
|
|
booleanPointInPolygon(
|
|
[tournament.latLng.lng, tournament.latLng.lat],
|
|
feature.geometry,
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
export const filteredTournamentsListAtom = atom((get) => {
|
|
const tournaments = get(filteredTournamentsByTimeControlAndZoneAtom);
|
|
const mapBounds = get(mapBoundsAtom);
|
|
const regionFilter = get(regionFilterAtom);
|
|
const normsOnly = get(normsOnlyAtom);
|
|
const searchString = get(searchStringAtom).trim();
|
|
|
|
const filteredByNorm = normsOnly
|
|
? tournaments.filter((t) => t.norm)
|
|
: tournaments;
|
|
|
|
// When searching, we search all the tournament, regardless of the map display
|
|
if (searchString !== "") {
|
|
return filteredByNorm.filter(
|
|
(t) =>
|
|
normalizedContains(t.town, searchString) ||
|
|
normalizedContains(t.tournament, searchString),
|
|
);
|
|
}
|
|
|
|
// If we not syncing to the map, return all tournaments
|
|
if (mapBounds === null || regionFilter !== "map") return filteredByNorm;
|
|
|
|
// Filter by the map bounds
|
|
return filteredByNorm.filter((tournament) =>
|
|
mapBounds.contains(tournament.latLng),
|
|
);
|
|
});
|
|
|
|
export const filteredClubsByZoneAtom = atom((get) => {
|
|
const clubs = get(clubsAtom);
|
|
const regionFilter = get(regionFilterAtom);
|
|
|
|
if (
|
|
regionFilter === "all" ||
|
|
regionFilter === "map" ||
|
|
regionFilter === "region"
|
|
)
|
|
return clubs;
|
|
|
|
if (isFeature(regionFilter)) {
|
|
return clubs.filter((club) => {
|
|
return booleanPointInPolygon(
|
|
[club.latLng.lng, club.latLng.lat],
|
|
regionFilter.geometry,
|
|
);
|
|
});
|
|
}
|
|
|
|
return clubs.filter((club) => {
|
|
return regionFilter.features?.features?.some(
|
|
(feature) =>
|
|
feature.geometry.type === "Polygon" &&
|
|
booleanPointInPolygon(
|
|
[club.latLng.lng, club.latLng.lat],
|
|
feature.geometry,
|
|
),
|
|
);
|
|
});
|
|
});
|
|
|
|
export const filteredClubsListAtom = atom((get) => {
|
|
const filteredByZone = get(filteredClubsByZoneAtom);
|
|
const mapBounds = get(mapBoundsAtom);
|
|
const regionFilter = get(regionFilterAtom);
|
|
const searchString = get(searchStringAtom).trim();
|
|
|
|
// When searching, we search all the tournament, regardless of the map display
|
|
if (searchString !== "") {
|
|
return filteredByZone.filter(
|
|
(club) =>
|
|
normalizedContains(club.name, searchString) ||
|
|
(club.address && normalizedContains(club.address, searchString)),
|
|
);
|
|
}
|
|
|
|
// If we not syncing to the map, return all clubs
|
|
if (mapBounds === null || regionFilter !== "map") return filteredByZone;
|
|
|
|
// Filter by the map bounds
|
|
return filteredByZone.filter((club) => mapBounds.contains(club.latLng));
|
|
});
|
|
|
|
// Date picker atoms
|
|
export const datePickerIsOpenAtom = atom(false);
|
|
|
|
export const maxDateAtom = atom((get) => {
|
|
const tournaments = get(tournamentsAtom);
|
|
const dateTimestamps = tournaments.map((t) =>
|
|
endOfDay(parse(t.date, "dd/MM/yyyy", new Date())).getTime(),
|
|
);
|
|
|
|
return new Date(Math.max(...dateTimestamps));
|
|
});
|
|
|
|
export const dateRangeAtom = atom<any>([
|
|
{
|
|
startDate: new Date(),
|
|
endDate: undefined,
|
|
key: "selection",
|
|
},
|
|
]);
|