birdclaw 0.8.2 → 0.8.4

package/dist/server/assets/network-map-D3CzRcC4.js

@@ -0,0 +1,224 @@
+import "./ui-qbmcMSSX.js";
+import { C as networkMapResponseSchema, a as fetchQueryEnvelope, n as queryKeys, r as fetchJson } from "./query-client-BdauHBgd.js";
+import { r as useSelectedAccountId } from "./account-selection-CTdFGWRk.js";
+import { o as validateNetworkMapSearch } from "./route-search-BUlQ5lGM.js";
+import { useMemo, useState } from "react";
+import { createFileRoute, lazyRouteComponent } from "@tanstack/react-router";
+import "react/jsx-runtime";
+import "lucide-react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import Supercluster from "supercluster";
+//#region src/components/network-map-model.ts
+var MAP_TYPES = [
+	{
+		value: "all",
+		label: "All"
+	},
+	{
+		value: "followers",
+		label: "Followers"
+	},
+	{
+		value: "following",
+		label: "Following"
+	},
+	{
+		value: "mutual",
+		label: "Mutual"
+	}
+];
+var WORLD_VIEWPORT = {
+	bounds: [
+		-180,
+		-85,
+		180,
+		85
+	],
+	zoom: 1.15
+};
+async function fetchMap(type, refresh, accountId, signal) {
+	const url = new URL("/api/network-map", window.location.origin);
+	url.searchParams.set("type", type);
+	url.searchParams.set("limit", "50000");
+	url.searchParams.set("geocodeLimit", refresh ? "80" : "12");
+	if (accountId) url.searchParams.set("account", accountId);
+	if (refresh) url.searchParams.set("refresh", "true");
+	return fetchJson(url, { signal }, networkMapResponseSchema, "Map request failed");
+}
+function formatNumber(value) {
+	return new Intl.NumberFormat().format(value);
+}
+function formatRelationship(value) {
+	if (value === "mutual") return "mutual";
+	if (value === "following") return "following";
+	return "follower";
+}
+function relationshipColor(relationship) {
+	if (relationship === "mutual") return "#22c55e";
+	if (relationship === "following") return "#f59e0b";
+	return "#1d9bf0";
+}
+function avatarInitial(feature) {
+	return (feature.properties.name || feature.properties.handle || "?").slice(0, 1).toUpperCase();
+}
+function avatarPath(feature) {
+	if (!feature.properties.avatarUrl) return null;
+	return `/api/avatar?${new URLSearchParams({
+		profileId: feature.properties.profileId,
+		v: feature.properties.avatarUrl
+	}).toString()}`;
+}
+function clusterGradient(stats) {
+	const total = Math.max(1, stats.followers + stats.following + stats.mutual);
+	const mutual = stats.mutual / total * 100;
+	const following = mutual + stats.following / total * 100;
+	return `conic-gradient(#22c55e 0 ${mutual}%, #f59e0b ${mutual}% ${following}%, #1d9bf0 ${following}% 100%)`;
+}
+function buildClusterIndex(features) {
+	const points = features.map((feature, featureIndex) => ({
+		type: "Feature",
+		geometry: feature.geometry,
+		properties: {
+			featureIndex,
+			handle: feature.properties.handle,
+			name: feature.properties.name,
+			avatarUrl: feature.properties.avatarUrl,
+			relationship: feature.properties.relationship,
+			followersCount: feature.properties.followersCount
+		}
+	}));
+	return new Supercluster({
+		maxZoom: 18,
+		minPoints: 2,
+		radius: 64,
+		map: (props) => ({
+			followers: props.relationship === "followers" ? 1 : 0,
+			following: props.relationship === "following" ? 1 : 0,
+			mutual: props.relationship === "mutual" ? 1 : 0
+		}),
+		reduce: (accumulated, props) => {
+			accumulated.followers += props.followers;
+			accumulated.following += props.following;
+			accumulated.mutual += props.mutual;
+		}
+	}).load(points);
+}
+function isCluster(item) {
+	return "cluster" in item.properties && item.properties.cluster === true;
+}
+function compareClusterFeatures(a, b) {
+	return b.properties.followersCount - a.properties.followersCount || a.properties.handle.localeCompare(b.properties.handle);
+}
+function getClusterDisplayAnchor(features, fallback) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const feature of features) {
+		const [lng, lat] = feature.geometry.coordinates;
+		const key = `${lng.toFixed(4)},${lat.toFixed(4)}`;
+		const existing = buckets.get(key);
+		if (existing) {
+			existing.count += 1;
+			existing.followers += feature.properties.followersCount;
+		} else buckets.set(key, {
+			coordinates: [lng, lat],
+			count: 1,
+			followers: feature.properties.followersCount
+		});
+	}
+	return [...buckets.values()].sort((a, b) => b.count - a.count || b.followers - a.followers)[0]?.coordinates ?? fallback;
+}
+function readViewport(target) {
+	if (!target || typeof target !== "object") return null;
+	const map = target;
+	if (typeof map.getBounds !== "function" || typeof map.getZoom !== "function") return null;
+	const bounds = map.getBounds();
+	return {
+		bounds: [
+			bounds.getWest(),
+			bounds.getSouth(),
+			bounds.getEast(),
+			bounds.getNorth()
+		],
+		zoom: map.getZoom()
+	};
+}
+function boundsContainFeature(bounds, feature) {
+	const [west, south, east, north] = bounds;
+	const [lng, lat] = feature.geometry.coordinates;
+	const normalizedWest = (west + 540) % 360 - 180;
+	const normalizedEast = (east + 540) % 360 - 180;
+	const inLatitude = lat >= Math.max(-85, south) && lat <= Math.min(85, north);
+	const inLongitude = east - west >= 360 ? true : normalizedWest <= normalizedEast ? lng >= normalizedWest && lng <= normalizedEast : lng >= normalizedWest || lng <= normalizedEast;
+	return inLatitude && inLongitude;
+}
+function featureMatchesSearch(feature, search) {
+	const needle = search.trim().toLowerCase();
+	if (!needle) return true;
+	return [
+		feature.properties.name,
+		feature.properties.handle,
+		feature.properties.location,
+		feature.properties.resolvedLocation ?? "",
+		formatRelationship(feature.properties.relationship)
+	].join(" ").toLowerCase().includes(needle);
+}
+//#endregion
+//#region src/components/network-map-controller.ts
+function useNetworkMapController(filters, onFiltersChange) {
+	const queryClient = useQueryClient();
+	const { type, q: visibleSearch } = filters;
+	const [viewport, setViewport] = useState(WORLD_VIEWPORT);
+	const selectedAccountId = useSelectedAccountId(useQuery({
+		queryKey: queryKeys.status,
+		queryFn: ({ signal }) => fetchQueryEnvelope({ signal })
+	}).data?.accounts);
+	const mapQueryKey = [...queryKeys.networkMap, {
+		type,
+		selectedAccountId: selectedAccountId ?? null
+	}];
+	const mapQuery = useQuery({
+		queryKey: mapQueryKey,
+		queryFn: ({ signal }) => fetchMap(type, false, selectedAccountId, signal),
+		staleTime: 5 * 6e4
+	});
+	const refreshMutation = useMutation({
+		mutationFn: () => fetchMap(type, true, selectedAccountId),
+		onSuccess: (nextData) => {
+			queryClient.setQueryData(mapQueryKey, nextData);
+		}
+	});
+	const data = mapQuery.data ?? null;
+	const loading = mapQuery.isPending || refreshMutation.isPending;
+	const queryError = refreshMutation.error ?? mapQuery.error;
+	const visibleFeatures = useMemo(() => (data?.features ?? []).slice().filter((feature) => boundsContainFeature(viewport.bounds, feature)).sort((a, b) => b.properties.followersCount - a.properties.followersCount || a.properties.handle.localeCompare(b.properties.handle)), [data, viewport]);
+	const filteredVisibleFeatures = useMemo(() => visibleFeatures.filter((feature) => featureMatchesSearch(feature, visibleSearch)).slice(0, 160), [visibleFeatures, visibleSearch]);
+	return {
+		type,
+		setType: (value) => onFiltersChange({
+			...filters,
+			type: value
+		}),
+		viewport,
+		setViewport,
+		visibleSearch,
+		setVisibleSearch: (value) => onFiltersChange({
+			...filters,
+			q: value
+		}, { replace: true }),
+		data,
+		loading,
+		error: queryError ? queryError instanceof Error ? queryError.message : "Map unavailable" : null,
+		refresh: refreshMutation.mutate,
+		visibleFeatures,
+		filteredVisibleFeatures,
+		mapTypes: MAP_TYPES
+	};
+}
+//#endregion
+//#region src/routes/network-map.tsx
+var $$splitComponentImporter = () => import("./network-map-D5DoLOwR.js");
+var Route$1 = createFileRoute("/network-map")({
+	component: lazyRouteComponent($$splitComponentImporter, "component"),
+	validateSearch: validateNetworkMapSearch
+});
+//#endregion
+export { avatarPath as a, compareClusterFeatures as c, getClusterDisplayAnchor as d, isCluster as f, avatarInitial as i, formatNumber as l, relationshipColor as m, useNetworkMapController as n, buildClusterIndex as o, readViewport as p, WORLD_VIEWPORT as r, clusterGradient as s, Route$1 as t, formatRelationship as u };