118 lines
3.7 KiB
TypeScript
118 lines
3.7 KiB
TypeScript
import { immich } from './immich';
|
|
import { getConfig } from './config';
|
|
import { cache } from './cache';
|
|
|
|
/** A clustered map marker — one per unique city/country. */
|
|
export interface MapLocation {
|
|
city: string;
|
|
country: string;
|
|
lat: number;
|
|
lng: number;
|
|
photoCount: number;
|
|
coverAssetId: string;
|
|
albums: { name: string; slug: string; subpageSlug?: string }[];
|
|
}
|
|
|
|
/**
|
|
* Aggregate all geotagged photos into location-level markers.
|
|
* Returns one entry per unique city+country with averaged lat/lng.
|
|
*/
|
|
let pendingMapDataPromise: Promise<MapLocation[]> | null = null;
|
|
|
|
export async function getMapData(): Promise<MapLocation[]> {
|
|
const config = getConfig();
|
|
const cacheKey = 'map-data';
|
|
const cached = cache.get<MapLocation[]>(cacheKey);
|
|
if (cached) return cached;
|
|
|
|
if (pendingMapDataPromise) return pendingMapDataPromise;
|
|
|
|
pendingMapDataPromise = (async () => {
|
|
try {
|
|
const albums = await immich.getAlbums();
|
|
|
|
// Build a lookup: album ID → { name, slug, subpageSlug? }
|
|
const albumMeta = new Map<string, { name: string; slug: string; subpageSlug?: string }>();
|
|
for (const a of albums) {
|
|
// Check if this album belongs to a subpage
|
|
const sp = config.subpages.find((s) => s.albumIds.includes(a.id));
|
|
albumMeta.set(a.id, { name: a.albumName, slug: a.slug, subpageSlug: sp?.slug });
|
|
}
|
|
|
|
// Fetch full album data (with assets) for each
|
|
// Process in chunks of 10 to balance network speed and prevent Out of Memory (OOM)
|
|
// crashes from fetching thousands of assets simultaneously.
|
|
const fullAlbums: (Awaited<ReturnType<typeof immich.getAlbum>> | null)[] = [];
|
|
const chunkSize = 10;
|
|
for (let i = 0; i < albums.length; i += chunkSize) {
|
|
const chunk = albums.slice(i, i + chunkSize);
|
|
const chunkResults = await Promise.all(chunk.map((a) => immich.getAlbum(a.id)));
|
|
fullAlbums.push(...chunkResults);
|
|
}
|
|
|
|
// Bucket assets by city+country
|
|
const buckets = new Map<
|
|
string,
|
|
{
|
|
latSum: number;
|
|
lngSum: number;
|
|
count: number;
|
|
coverAssetId: string;
|
|
albumIds: Set<string>;
|
|
}
|
|
>();
|
|
|
|
for (const album of fullAlbums) {
|
|
if (!album) continue;
|
|
for (const asset of album.assets) {
|
|
const exif = asset.exifInfo;
|
|
if (!exif?.latitude || !exif?.longitude || !exif?.city || !exif?.country) continue;
|
|
|
|
const key = `${exif.city}|${exif.country}`;
|
|
let bucket = buckets.get(key);
|
|
if (!bucket) {
|
|
bucket = {
|
|
latSum: 0,
|
|
lngSum: 0,
|
|
count: 0,
|
|
coverAssetId: asset.id,
|
|
albumIds: new Set(),
|
|
};
|
|
buckets.set(key, bucket);
|
|
}
|
|
bucket.latSum += exif.latitude;
|
|
bucket.lngSum += exif.longitude;
|
|
bucket.count++;
|
|
bucket.albumIds.add(album.id);
|
|
}
|
|
}
|
|
|
|
// Convert buckets to MapLocation[]
|
|
const locations: MapLocation[] = [];
|
|
for (const [key, bucket] of buckets) {
|
|
const [city, country] = key.split('|');
|
|
const lat = bucket.latSum / bucket.count;
|
|
const lng = bucket.lngSum / bucket.count;
|
|
locations.push({
|
|
city,
|
|
country,
|
|
lat,
|
|
lng,
|
|
photoCount: bucket.count,
|
|
coverAssetId: bucket.coverAssetId,
|
|
albums: [...bucket.albumIds]
|
|
.map((id) => albumMeta.get(id))
|
|
.filter((m): m is NonNullable<typeof m> => !!m),
|
|
});
|
|
}
|
|
|
|
cache.set(cacheKey, locations, config.cacheTtl);
|
|
return locations;
|
|
} finally {
|
|
pendingMapDataPromise = null;
|
|
}
|
|
})();
|
|
|
|
return pendingMapDataPromise;
|
|
}
|