@buildcanada/charts 0.3.7 → 0.3.8

package/dist/grapher/mapCharts/GlobeController.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/grapher/mapCharts/GlobeController.ts"],
+  "sourcesContent": ["import { FeatureCollection } from \"geojson\"\nimport { geoInterpolate, geoOrthographic, geoPath } from \"d3-geo\"\nimport { interpolateNumber } from \"d3-interpolate\"\nimport { easeCubicOut } from \"d3-ease\"\nimport * as R from \"remeda\"\nimport { EntityName, GlobeConfig, GlobeRegionName } from \"../../types/index.js\"\nimport {\n    Bounds,\n    excludeUndefined,\n    PartialBy,\n    PointVector,\n    checkIsContinent,\n    getCountryNamesForRegion,\n    getRegionByName,\n    checkHasMembers,\n} from \"../../utils/index.js\"\nimport { MapConfig } from \"./MapConfig.js\"\nimport { getGeoFeaturesForGlobe } from \"./GeoFeatures.js\"\nimport {\n    DEFAULT_GLOBE_ROTATION,\n    DEFAULT_GLOBE_ROTATIONS_FOR_TIME,\n    DEFAULT_GLOBE_SIZE,\n    GeoFeature,\n    GLOBE_COUNTRY_ZOOM,\n    GLOBE_LATITUDE_MAX,\n    GLOBE_LATITUDE_MIN,\n    GLOBE_MAX_ZOOM,\n    GLOBE_MIN_ZOOM,\n    GLOBE_VIEWPORTS,\n    GlobeRenderFeature,\n    MAP_REGION_NAMES,\n} from \"./MapChartConstants.js\"\nimport { isPointPlacedOnVisibleHemisphere } from \"./MapHelpers.js\"\nimport { ckmeans } from \"simple-statistics\"\nimport { MapSelectionArray } from \"../selection/MapSelectionArray.js\"\nimport { center } from \"@turf/center\"\nimport { action } from \"mobx\"\n\nconst geoFeaturesById = new Map<string, GlobeRenderFeature>(\n    getGeoFeaturesForGlobe().map((f: GlobeRenderFeature) => [f.id, f])\n)\n\nconst LONGITUDE_OFFSET = 40\nconst ANIMATION_DURATION = 600\n\ninterface Target {\n    coords: [number, number]\n    zoom: number\n}\n\ninterface GlobeControllerManager {\n    mapConfig: MapConfig\n}\n\nexport class GlobeController {\n    private manager: GlobeControllerManager\n\n    constructor(manager: GlobeControllerManager) {\n        this.manager = manager\n    }\n\n    private get globeConfig(): GlobeConfig {\n        return this.manager.mapConfig.globe\n    }\n\n    @action.bound showGlobe(): void {\n        this.globeConfig.isActive = true\n    }\n\n    @action.bound hideGlobe(): void {\n        this.globeConfig.isActive = false\n    }\n\n    @action.bound toggleGlobe(): void {\n        this.globeConfig.isActive = !this.globeConfig.isActive\n    }\n\n    @action.bound resetGlobe(): void {\n        this.globeConfig.rotation = DEFAULT_GLOBE_ROTATION\n        this.globeConfig.zoom = 1\n        this.globeConfig.focusCountry = undefined\n    }\n\n    @action.bound setFocusCountry(country: EntityName): void {\n        this.globeConfig.focusCountry = country\n    }\n\n    @action.bound dismissCountryFocus(): void {\n        this.globeConfig.focusCountry = undefined\n    }\n\n    @action.bound private jumpTo(target: Partial<Target>): void {\n        if (target.coords) this.globeConfig.rotation = target.coords\n        if (target.zoom) this.globeConfig.zoom = target.zoom\n    }\n\n    private showGlobeAndRotateTo(target: Target): void {\n        // if the globe isn't currently shown, jump to the offset position\n        // before switching to it so that rotating is predictable\n        if (!this.globeConfig.isActive) {\n            this.jumpTo({ coords: addLongitudeOffset(target.coords) })\n            this.showGlobe()\n        }\n\n        void this.rotateTo(target)\n    }\n\n    jumpToContinent(continent: GlobeRegionName): void {\n        const target = calculateTargetForContinent(continent)\n        this.jumpTo(target)\n    }\n\n    rotateToCountry(country: EntityName, zoom?: number): void {\n        const target = calculateTargetForCountry(country, zoom)\n        if (target) this.showGlobeAndRotateTo(target)\n    }\n\n    rotateToContinent(continent: GlobeRegionName): void {\n        const target = calculateTargetForContinent(continent)\n        this.showGlobeAndRotateTo(target)\n    }\n\n    rotateToDefaultBasedOnTime(): void {\n        const target = calculateTargetBasedOnTime()\n        this.showGlobeAndRotateTo(target)\n    }\n\n    rotateToSelection(): void {\n        const target = calculateTargetForSelection(\n            this.manager.mapConfig.selection\n        )\n        if (target) this.showGlobeAndRotateTo(target)\n    }\n\n    rotateToRegion(regionName: string): void {\n        const target = calculateTargetForRegion(regionName)\n        if (target) this.showGlobeAndRotateTo(target)\n    }\n\n    private currentAnimation?: AbortController\n    private async rotateTo(target: PartialBy<Target, \"zoom\">): Promise<void> {\n        // cancel any ongoing rotation\n        if (this.currentAnimation) {\n            this.currentAnimation.abort()\n            this.currentAnimation = undefined\n        }\n\n        // set up a new abort controller\n        const controller = new AbortController()\n        this.currentAnimation = controller\n\n        try {\n            await this._rotateTo(controller.signal, target.coords, target.zoom)\n        } catch {\n            // aborted\n        } finally {\n            if (this.currentAnimation === controller) {\n                this.currentAnimation = undefined\n            }\n        }\n    }\n\n    private async _rotateTo(\n        signal: AbortSignal,\n        targetCoords: [number, number],\n        targetZoom?: number\n    ): Promise<void> {\n        const currentCoords = this.globeConfig.rotation\n        const animatedCoords = geoInterpolate(currentCoords, targetCoords)\n\n        const currentZoom = this.globeConfig.zoom\n        const animatedZoom =\n            targetZoom !== undefined\n                ? interpolateNumber(currentZoom, targetZoom)\n                : undefined\n\n        const animPromise = new Promise<void>((resolve, reject) => {\n            const now = Date.now()\n            const step = action((): void => {\n                const elapsed = Date.now() - now\n                const t = Math.min(1, elapsed / ANIMATION_DURATION)\n\n                // Check if the animation was canceled\n                if (signal.aborted) {\n                    reject()\n                    return\n                }\n\n                // animate globe rotation\n                this.globeConfig.rotation = animatedCoords(easeCubicOut(t))\n\n                // animate zoom\n                if (animatedZoom)\n                    this.globeConfig.zoom = animatedZoom(easeCubicOut(t))\n\n                if (t < 1) {\n                    requestAnimationFrame(step)\n                } else {\n                    resolve()\n                }\n            })\n            requestAnimationFrame(step)\n        })\n\n        await animPromise\n            .catch(() => {\n                // ignore\n            })\n            .then(\n                action(() => {\n                    // ensure we end exactly at the target values\n                    this.globeConfig.rotation = targetCoords\n                    if (targetZoom !== undefined)\n                        this.globeConfig.zoom = targetZoom\n                })\n            )\n    }\n}\n\nfunction calculateTargetForCountry(\n    country: EntityName,\n    zoom?: number\n): Target | undefined {\n    const geoFeature = geoFeaturesById.get(country)\n    if (!geoFeature) return\n\n    const coords: [number, number] = [\n        geoFeature.geoCentroid[0],\n        R.clamp(geoFeature.geoCentroid[1], {\n            min: GLOBE_LATITUDE_MIN,\n            max: GLOBE_LATITUDE_MAX,\n        }),\n    ]\n\n    // make sure the whole country is visible after zooming\n    const zoomToFit = calculateZoomToFitForGeoFeature(geoFeature.geo)\n    const targetZoom = Math.min(zoom ?? GLOBE_COUNTRY_ZOOM, zoomToFit)\n\n    return { coords, zoom: targetZoom }\n}\n\nfunction calculateZoomToFitForGeoFeature(geoFeature: GeoFeature): number {\n    const centerPoint = getCenterPoint(geoFeature)\n    const projection = geoOrthographic().rotate(negateCoords(centerPoint))\n\n    const corners = geoPath().projection(projection).bounds(geoFeature)\n    const bounds = Bounds.fromCorners(\n        new PointVector(...corners[0]),\n        new PointVector(...corners[1])\n    )\n\n    return calculateZoomToFitForBounds(bounds)\n}\n\nfunction calculateZoomToFitForBounds(bounds: Bounds): number {\n    // calculate the zoom needed for the bounds to be visible\n    let zoom = Math.min(\n        DEFAULT_GLOBE_SIZE / bounds.width,\n        DEFAULT_GLOBE_SIZE / bounds.height\n    )\n    if (Number.isNaN(zoom)) zoom = 1\n\n    // it's nicer to have a bit of padding around the zoomed-to area\n    zoom = zoom - 0.05\n\n    // clamp the zoom to the allowed range\n    zoom = R.clamp(zoom, { min: GLOBE_MIN_ZOOM, max: GLOBE_MAX_ZOOM })\n\n    return zoom\n}\n\nfunction calculateTargetForContinent(continent: GlobeRegionName): Target {\n    const viewport = GLOBE_VIEWPORTS[continent]\n    return { coords: viewport.rotation, zoom: viewport.zoom }\n}\n\nfunction calculateTargetBasedOnTime(): Target {\n    const coords = getCoordsBasedOnTime()\n    return { coords, zoom: 1 }\n}\n\nfunction calculateTargetForRegion(regionName: string): Target | undefined {\n    const region = getRegionByName(regionName)\n    if (!region || !checkHasMembers(region)) return\n    const countryNames = getCountryNamesForRegion(region)\n    return calculateTargetForCountryCollection(countryNames)\n}\n\nfunction calculateTargetForSelection(\n    selection: MapSelectionArray\n): Target | undefined {\n    // if at least one country is selected, then rotate to the countries (and ignore the regions)\n    if (selection.selectedCountryNamesInForeground.length > 0) {\n        return calculateTargetForCountryCollection(\n            selection.selectedCountryNamesInForeground\n        )\n    }\n\n    // if a single continent is selected, then rotate to it\n    // (the hard-coded coords/zoom values are nicer than dynamically computing it)\n    if (\n        selection.selectedRegions.length === 1 &&\n        checkIsContinent(selection.selectedRegions[0])\n    ) {\n        return calculateTargetForContinent(\n            MAP_REGION_NAMES[\n                selection.selectedRegions[0].name\n            ] as GlobeRegionName\n        )\n    }\n\n    // rotate and zoom to all countries in the selected regions\n    const countryNames = [\n        ...selection.selectedCountryNamesInForeground,\n        ...selection.countryNamesForSelectedRegions,\n    ]\n    return calculateTargetForCountryCollection(countryNames)\n}\n\nfunction calculateTargetForCountryCollection(\n    countryNames: string[]\n): Target | undefined {\n    // early return if the selection is empty or a single country is selected\n    if (countryNames.length === 0) return\n    if (countryNames.length === 1) {\n        return calculateTargetForCountry(countryNames[0])\n    }\n\n    // find a subset of countries that can be shown on the globe,\n    // e.g. if 'Mexico', 'Guatemala' and 'Australia' are selected, then\n    // 'Australia' is dropped as it's on the opposite site from South America\n    const visibleCountries = findVisibleCountrySubset(countryNames)\n\n    // early return if no country or a single country is visible\n    if (visibleCountries.length === 0) return\n    if (visibleCountries.length === 1) {\n        return calculateTargetForCountry(visibleCountries[0])\n    }\n\n    // calculate target coords and zoom for two or more countries\n    return getCoordsAndZoomForCountryCollection(visibleCountries)\n}\n\nfunction getCoordsBasedOnTime(): [number, number] {\n    const date = new Date()\n    const hours = date.getUTCHours()\n\n    if (hours <= 7) {\n        return DEFAULT_GLOBE_ROTATIONS_FOR_TIME.UTC_MORNING\n    } else if (hours <= 15) {\n        return DEFAULT_GLOBE_ROTATIONS_FOR_TIME.UTC_MIDDAY\n    } else {\n        return DEFAULT_GLOBE_ROTATIONS_FOR_TIME.UTC_EVENING\n    }\n}\n\nfunction getCenterForCountryCollection(\n    countryNames: string[]\n): [number, number] {\n    const featureCollection = makeFeatureCollectionForCountries(countryNames)\n    return getCenterPoint(featureCollection)\n}\n\nfunction getCenterPoint(\n    geojson: GeoFeature | FeatureCollection\n): [number, number] {\n    const centerPoint = center(geojson)\n\n    return [\n        centerPoint.geometry.coordinates[0],\n        R.clamp(centerPoint.geometry.coordinates[1], {\n            min: GLOBE_LATITUDE_MIN,\n            max: GLOBE_LATITUDE_MAX,\n        }),\n    ]\n}\n\nfunction getCoordsAndZoomForCountryCollection(countryNames: string[]): {\n    coords: [number, number]\n    zoom: number\n} {\n    const centerPoint = getCenterForCountryCollection(countryNames)\n    const projection = geoOrthographic().rotate(negateCoords(centerPoint))\n\n    const bounds = excludeUndefined(\n        countryNames.map((countryName) => {\n            const feature = geoFeaturesById.get(countryName)\n            if (!feature) return\n            const corners = geoPath().projection(projection).bounds(feature.geo)\n            if (corners[0][0] === Number.POSITIVE_INFINITY) return\n            return Bounds.fromCorners(\n                new PointVector(...corners[0]),\n                new PointVector(...corners[1])\n            )\n        })\n    )\n\n    // merge bounds and calculate the zoom needed for the countries to be visible\n    const mergedBounds = Bounds.merge(bounds)\n    const zoom = calculateZoomToFitForBounds(mergedBounds)\n\n    return { coords: centerPoint, zoom }\n}\n\nfunction findVisibleCountrySubset(countryNames: string[]): string[] {\n    // rotate the globe to the center point of all given countries,\n    // and find all countries that are then visible on the globe\n    const centerPoint = getCenterForCountryCollection(countryNames)\n    const projection = geoOrthographic().rotate(negateCoords(centerPoint))\n    const visibleCountries = countryNames.filter((countryName) => {\n        const feature = geoFeaturesById.get(countryName)\n        if (!feature) return false\n\n        // check if the centroid is visible\n        const isCentroidVisible = isPointPlacedOnVisibleHemisphere(\n            feature.geoCentroid,\n            centerPoint\n        )\n        if (!isCentroidVisible) return false\n\n        // if the centroid is visible, then also check if the bounds are\n        // visible (if they're infinite, then they're not)\n        const corners = geoPath().projection(projection).bounds(feature.geo)\n        if (corners[0][0] === Number.POSITIVE_INFINITY) return false\n\n        return true\n    })\n\n    // it's possible for no country to be visible if the countries are on opposite\n    // sides from the globe. in that case, we need to drop a subset of countries\n    if (visibleCountries.length === 0) {\n        // cluster countries into two groups based on their centroid longitude\n        const clusters = clusterCountriesByCentroidLongitude(countryNames)\n\n        // keep the bigger cluster\n        // (if both clusters have the same number of countries, keep any)\n        return clusters[0].length > clusters[1].length\n            ? clusters[0]\n            : clusters[1]\n    }\n\n    return visibleCountries\n}\n\nfunction clusterCountriesByCentroidLongitude(\n    countryNames: string[]\n): string[][] {\n    const nameToLon: Record<string, number> = {}\n    const lonToName: Record<number, string> = {}\n\n    // map country names to their centroid's longitude and vice versa\n    // (assumes that no two countries have the same longitude)\n    countryNames.forEach((countryName) => {\n        const feature = geoFeaturesById.get(countryName)\n        if (!feature) return\n\n        const lon = R.round(feature.geoCentroid[0], 5)\n        nameToLon[countryName] = lon\n        lonToName[lon] = countryName\n    })\n\n    // cluster longitudes into two groups\n    const clusters = ckmeans(\n        excludeUndefined(countryNames.map((name) => nameToLon[name])),\n        2\n    )\n\n    // map longitudes back to country names\n    return clusters.map((cluster) =>\n        cluster.map((centroidLon) => lonToName[centroidLon])\n    )\n}\n\nfunction makeFeatureCollectionForCountries(\n    countryNames: string[]\n): FeatureCollection {\n    const features = excludeUndefined(\n        countryNames.map((name) => geoFeaturesById.get(name))\n    )\n\n    return {\n        type: \"FeatureCollection\",\n        features: features.map((feature) => feature.geo),\n    }\n}\n\nfunction addLongitudeOffset(\n    coords: [number, number],\n    offset = LONGITUDE_OFFSET\n): [number, number] {\n    return [coords[0] + offset, coords[1]]\n}\n\nfunction negateCoords(coords: [number, number]): [number, number] {\n    return [-coords[0], -coords[1]]\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/grapher/mapCharts/MapAnnotationPlacements.d.ts

@@ -0,0 +1,14 @@
+import { Direction, EllipseCoords, GeoFeature } from "./MapChartConstants.js";
+interface RawAnnotationPlacement {
+    id: string;
+    ellipse?: EllipseCoords;
+    direction?: Direction;
+    anchorPoint?: [number, number];
+    bridgeCountries?: string[];
+}
+interface EnrichedAnnotationPlacement extends Omit<RawAnnotationPlacement, "bridgeCountries"> {
+    bridgeFeatures?: GeoFeature[];
+}
+export declare const annotationPlacementsById: Map<string, EnrichedAnnotationPlacement>;
+export {};
+//# sourceMappingURL=MapAnnotationPlacements.d.ts.map

package/dist/grapher/mapCharts/MapAnnotationPlacements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapAnnotationPlacements.d.ts","sourceRoot":"","sources":["../../../src/grapher/mapCharts/MapAnnotationPlacements.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAE7E,UAAU,sBAAsB;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC7B;AAED,UAAU,2BACN,SAAQ,IAAI,CAAC,sBAAsB,EAAE,iBAAiB,CAAC;IACvD,cAAc,CAAC,EAAE,UAAU,EAAE,CAAA;CAChC;AAED,eAAO,MAAM,wBAAwB,0CAapC,CAAA"}

package/dist/grapher/mapCharts/MapAnnotationPlacements.js

@@ -0,0 +1,16 @@
+import { GeoFeaturesById } from "./GeoFeatures.js";
+import annotations from "./MapAnnotationPlacements.json";
+const annotationPlacementsById = new Map(
+  annotations.map((annotation) => {
+    const enrichedAnnotation = {
+      ...annotation,
+      bridgeFeatures: annotation.bridgeCountries?.map(
+        (name) => GeoFeaturesById.get(name)
+      )
+    };
+    return [annotation.id, enrichedAnnotation];
+  })
+);
+export {
+  annotationPlacementsById
+};

package/dist/grapher/mapCharts/MapAnnotationPlacements.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["src/grapher/mapCharts/MapAnnotationPlacements.ts"],
+  "sourcesContent": ["import { GeoFeaturesById } from \"./GeoFeatures.js\"\nimport annotations from \"./MapAnnotationPlacements.json\"\nimport { Direction, EllipseCoords, GeoFeature } from \"./MapChartConstants.js\"\n\ninterface RawAnnotationPlacement {\n    id: string\n    ellipse?: EllipseCoords\n    direction?: Direction\n    anchorPoint?: [number, number]\n    bridgeCountries?: string[]\n}\n\ninterface EnrichedAnnotationPlacement\n    extends Omit<RawAnnotationPlacement, \"bridgeCountries\"> {\n    bridgeFeatures?: GeoFeature[]\n}\n\nexport const annotationPlacementsById = new Map<\n    string,\n    EnrichedAnnotationPlacement\n>(\n    annotations.map((annotation) => {\n        const enrichedAnnotation = {\n            ...annotation,\n            bridgeFeatures: annotation.bridgeCountries?.map((name) =>\n                GeoFeaturesById.get(name)\n            ),\n        } as EnrichedAnnotationPlacement\n        return [annotation.id, enrichedAnnotation]\n    })\n)\n"],
+  "mappings": "AAAA,SAAS,uBAAuB;AAChC,OAAO,iBAAiB;AAgBjB,MAAM,2BAA2B,IAAI;AAAA,EAIxC,YAAY,IAAI,CAAC,eAAe;AAC5B,UAAM,qBAAqB;AAAA,MACvB,GAAG;AAAA,MACH,gBAAgB,WAAW,iBAAiB;AAAA,QAAI,CAAC,SAC7C,gBAAgB,IAAI,IAAI;AAAA,MAC5B;AAAA,IACJ;AACA,WAAO,CAAC,WAAW,IAAI,kBAAkB;AAAA,EAC7C,CAAC;AACL;",
+  "names": []
+}

package/dist/grapher/mapCharts/MapAnnotations.d.ts

@@ -0,0 +1,32 @@
+import { GeoProjection } from "d3-geo";
+import { Bounds } from "../../utils/index.js";
+import { Direction, RenderFeature, ExternalAnnotation, InternalAnnotation } from "./MapChartConstants.js";
+export declare function makeInternalAnnotationForFeature({ feature, projection, formattedValue, color, fontSizeScale, }: {
+    feature: RenderFeature;
+    projection: GeoProjection;
+    formattedValue: string;
+    color?: string;
+    fontSizeScale?: number;
+}): InternalAnnotation | undefined;
+export declare function makeExternalAnnotationForFeature({ feature, projection, formattedValue, fontSizeScale, }: {
+    feature: RenderFeature;
+    projection: GeoProjection;
+    formattedValue: string;
+    fontSizeScale?: number;
+}): ExternalAnnotation | undefined;
+/**
+ * Given a list of naively placed external annotations that might overlap,
+ * adjust label positions to minimise collisions and drop labels that can't
+ * be rendered.
+ */
+export declare function repositionAndFilterExternalAnnotations({ annotations, projection, backgroundFeatureIdSet, }: {
+    annotations: ExternalAnnotation[];
+    projection: GeoProjection;
+    backgroundFeatureIdSet: Set<string>;
+}): ExternalAnnotation[];
+export declare function getExternalMarkerEndPosition({ textBounds, direction, padding, }: {
+    textBounds: Bounds;
+    direction: Direction;
+    padding?: number;
+}): [number, number];
+//# sourceMappingURL=MapAnnotations.d.ts.map

package/dist/grapher/mapCharts/MapAnnotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapAnnotations.d.ts","sourceRoot":"","sources":["../../../src/grapher/mapCharts/MapAnnotations.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAKtC,OAAO,EAAE,MAAM,EAAoB,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EACH,SAAS,EAET,aAAa,EACb,kBAAkB,EAGlB,kBAAkB,EAQrB,MAAM,wBAAwB,CAAA;AAQ/B,wBAAgB,gCAAgC,CAAC,EAC7C,OAAO,EACP,UAAU,EACV,cAAc,EACd,KAAK,EACL,aAAiB,GACpB,EAAE;IACC,OAAO,EAAE,aAAa,CAAA;IACtB,UAAU,EAAE,aAAa,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,MAAM,CAAA;CACzB,GAAG,kBAAkB,GAAG,SAAS,CAiCjC;AAED,wBAAgB,gCAAgC,CAAC,EAC7C,OAAO,EACP,UAAU,EACV,cAAc,EACd,aAAiB,GACpB,EAAE;IACC,OAAO,EAAE,aAAa,CAAA;IACtB,UAAU,EAAE,aAAa,CAAA;IACzB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,CAAA;CACzB,GAAG,kBAAkB,GAAG,SAAS,CAkDjC;AAED;;;;GAIG;AACH,wBAAgB,sCAAsC,CAAC,EACnD,WAAW,EACX,UAAU,EACV,sBAAsB,GACzB,EAAE;IACC,WAAW,EAAE,kBAAkB,EAAE,CAAA;IACjC,UAAU,EAAE,aAAa,CAAA;IACzB,sBAAsB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACtC,GAAG,kBAAkB,EAAE,CA6DvB;AAoKD,wBAAgB,4BAA4B,CAAC,EACzC,UAAU,EACV,SAAS,EACT,OAAyB,GAC5B,EAAE;IACC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,SAAS,CAAA;IACpB,OAAO,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAqBnB"}

package/dist/grapher/mapCharts/MapAnnotations.js

@@ -0,0 +1,502 @@
+import { forceSimulation, forceX, forceY } from "d3-force";
+import bboxCollide from "./d3-bboxCollide.js";
+import { booleanIntersects } from "@turf/boolean-intersects";
+import { Bounds, excludeUndefined } from "../../utils/index.js";
+import {
+  ANNOTATION_FONT_SIZE_INTERNAL_DEFAULT,
+  ANNOTATION_FONT_SIZE_INTERNAL_MIN,
+  ANNOTATION_FONT_SIZE_EXTERNAL_DEFAULT,
+  ANNOTATION_FONT_SIZE_EXTERNAL_MAX,
+  ANNOTATION_MARKER_LINE_LENGTH_DEFAULT,
+  ANNOTATION_MARKER_LINE_LENGTH_MAX
+} from "./MapChartConstants.js";
+import * as R from "remeda";
+import { annotationPlacementsById } from "./MapAnnotationPlacements.js";
+import { GRAPHER_DARK_TEXT } from "../color/ColorConstants.js";
+import { getGeoFeaturesForGlobe } from "./GeoFeatures.js";
+const MARKER_TEXT_GAP = 2;
+function makeInternalAnnotationForFeature({
+  feature,
+  projection,
+  formattedValue,
+  color,
+  fontSizeScale = 1
+}) {
+  const placement = annotationPlacementsById.get(feature.id);
+  if (!placement || !placement.ellipse) return;
+  const ellipse = makeEllipseForProjection({
+    ellipse: placement.ellipse,
+    projection,
+    paddingFactor: { x: 0.1 }
+  });
+  if (!ellipse) return;
+  const placedLabel = placeLabelAtEllipseCenter({
+    text: formattedValue,
+    ellipse,
+    fontSizeScale
+  });
+  if (placedLabel)
+    return {
+      type: "internal",
+      id: feature.id,
+      feature,
+      placedBounds: placedLabel.placedBounds,
+      text: formattedValue,
+      ellipse,
+      fontSize: placedLabel.fontSize,
+      color: color ?? GRAPHER_DARK_TEXT
+    };
+  return;
+}
+function makeExternalAnnotationForFeature({
+  feature,
+  projection,
+  formattedValue,
+  fontSizeScale = 1
+}) {
+  const placement = annotationPlacementsById.get(feature.id);
+  if (!placement || !placement.anchorPoint || !placement.direction) return;
+  const direction = placement.direction;
+  const anchorPoint = projection(placement.anchorPoint);
+  if (!anchorPoint) return;
+  const fontSize = Math.min(
+    ANNOTATION_FONT_SIZE_EXTERNAL_DEFAULT / fontSizeScale,
+    ANNOTATION_FONT_SIZE_EXTERNAL_MAX
+  );
+  const markerLength = Math.min(
+    ANNOTATION_MARKER_LINE_LENGTH_DEFAULT / fontSizeScale,
+    ANNOTATION_MARKER_LINE_LENGTH_MAX
+  );
+  let placedBounds = placeExternalLabel({
+    text: formattedValue,
+    anchorPoint,
+    direction,
+    fontSize,
+    markerLength
+  });
+  if (placement.bridgeFeatures?.length)
+    placedBounds = moveExternalLabelIntoOcean({
+      bridgeFeatures: placement.bridgeFeatures,
+      placedBounds,
+      direction,
+      projection,
+      step: markerLength / 2,
+      maxSteps: 3
+    });
+  return {
+    type: "external",
+    id: feature.id,
+    feature,
+    text: formattedValue,
+    placedBounds,
+    anchor: anchorPoint,
+    direction,
+    fontSize,
+    color: GRAPHER_DARK_TEXT
+  };
+}
+function repositionAndFilterExternalAnnotations({
+  annotations,
+  projection,
+  backgroundFeatureIdSet
+  // countries ignored for collision detection
+}) {
+  const originalAnnotationsById = new Map(
+    annotations.map((annotation) => [annotation.id, annotation])
+  );
+  const nonOverlappingAnnotations = minimiseLabelCollisions(annotations);
+  const filteredAnnotations = nonOverlappingAnnotations.filter(
+    (annotation) => {
+      let nearbyGeoFeatures = getGeoFeaturesWithinRadius(
+        annotation.feature
+      );
+      if (backgroundFeatureIdSet.size > 0)
+        nearbyGeoFeatures = nearbyGeoFeatures.filter(
+          (feature) => !backgroundFeatureIdSet.has(feature.id)
+        );
+      const nearbyAnnotations = excludeUndefined(
+        nearbyGeoFeatures.map(
+          (feature) => originalAnnotationsById.get(feature.id)
+        )
+      );
+      return (
+        // hide an annotation if the line that connects the annotation
+        // with the anchor point crosses through other labels
+        !checkAnnotationMarkerCollidesWithSomeLabel({
+          annotation,
+          nearbyAnnotations
+        }) && // hide an annotation if it overlaps with other countries
+        !checkAnnotationCollidesWithLandmass({
+          annotation,
+          nearbyGeoFeatures,
+          projection
+        })
+      );
+    }
+  );
+  if (filteredAnnotations.length < annotations.length) {
+    return minimiseLabelCollisions(
+      filteredAnnotations.map((annotation) => {
+        const origBounds = originalAnnotationsById.get(
+          annotation.id
+        ).placedBounds;
+        return { ...annotation, placedBounds: origBounds };
+      })
+    );
+  }
+  return filteredAnnotations;
+}
+function placeLabelAtEllipseCenter({
+  text,
+  ellipse,
+  fontSizeScale = 1
+}) {
+  const defaultFontSize = ANNOTATION_FONT_SIZE_INTERNAL_DEFAULT / fontSizeScale;
+  const ellipseCenter = { x: ellipse.cx, y: ellipse.cy };
+  let placedBounds = makePlacedBoundsForText({
+    text,
+    fontSize: defaultFontSize,
+    fontWeight: 700,
+    position: ellipseCenter,
+    center: true
+  });
+  let textFits = checkPointIsInEllipse(placedBounds.topLeft, ellipse);
+  if (textFits) return { placedBounds, fontSize: defaultFontSize };
+  const step = 1;
+  for (let fontSize = ANNOTATION_FONT_SIZE_INTERNAL_DEFAULT - step; fontSize >= ANNOTATION_FONT_SIZE_INTERNAL_MIN; fontSize -= step) {
+    const scaledFontSize = fontSize / fontSizeScale;
+    placedBounds = makePlacedBoundsForText({
+      text,
+      fontSize: scaledFontSize,
+      fontWeight: 700,
+      position: ellipseCenter,
+      center: true
+    });
+    textFits = checkPointIsInEllipse(placedBounds.topLeft, ellipse);
+    if (textFits) return { placedBounds, fontSize: scaledFontSize };
+  }
+  return void 0;
+}
+function placeExternalLabel({
+  text,
+  anchorPoint,
+  direction,
+  fontSize,
+  markerLength,
+  padding = MARKER_TEXT_GAP
+}) {
+  const textBounds = Bounds.forText(text, { fontSize, fontWeight: 700 });
+  const labelPosition = calculateExternalLabelPosition({
+    anchorPoint,
+    textBounds,
+    direction,
+    markerLength,
+    padding
+  });
+  return textBounds.set({ x: labelPosition[0], y: labelPosition[1] });
+}
+function checkPointIsInEllipse(point, ellipse) {
+  const dx = point.x - ellipse.cx;
+  const dy = point.y - ellipse.cy;
+  return dx * dx / (ellipse.rx * ellipse.rx) + dy * dy / (ellipse.ry * ellipse.ry) <= 1;
+}
+function makeEllipseForProjection({
+  ellipse,
+  projection,
+  paddingFactor
+}) {
+  const projCenter = projection([ellipse.cx, ellipse.cy]);
+  const projLeft = projection([ellipse.left, ellipse.cy]);
+  const projTop = projection([ellipse.cx, ellipse.top]);
+  if (!projCenter || !projLeft || !projTop) return void 0;
+  const rx = Math.abs(projCenter[0] - projLeft[0]);
+  const ry = Math.abs(projCenter[1] - projTop[1]);
+  const padX = (paddingFactor?.x ?? 0) * rx;
+  const padY = (paddingFactor?.y ?? 0) * ry;
+  return {
+    cx: projCenter[0],
+    cy: projCenter[1],
+    rx: rx - padX,
+    ry: ry - padY
+  };
+}
+function calculateExternalLabelPosition({
+  anchorPoint,
+  textBounds,
+  direction,
+  markerLength,
+  padding = MARKER_TEXT_GAP
+}) {
+  const [x, y] = anchorPoint;
+  const w = textBounds.width, h = textBounds.height;
+  const m = markerLength + padding;
+  switch (direction) {
+    case "right":
+      return [x + m, y - h / 2];
+    case "left":
+      return [x - m - w, y - h / 2];
+    case "bottom":
+      return [x - w / 2, y + m];
+    case "top":
+      return [x - w / 2, y - h / 2 - m];
+    case "leftTop":
+      return [x - m - w, y - h / 2 - m / 2 - h];
+    case "leftBottom":
+      return [x - m - w, y - h / 2 + h + m / 2];
+    case "rightTop":
+      return [x + m, y - h / 2 - m / 2 - h];
+    case "rightBottom":
+      return [x + m, y - h / 2 + h + m / 2];
+  }
+}
+function getExternalMarkerEndPosition({
+  textBounds,
+  direction,
+  padding = MARKER_TEXT_GAP
+}) {
+  const { x, y, width, height } = textBounds;
+  switch (direction) {
+    case "right":
+      return [x - padding, y + height / 2];
+    case "left":
+      return [x + width + padding, y + height / 2];
+    case "bottom":
+      return [x + width / 2, y - padding];
+    case "top":
+      return [x + width / 2, y + height + padding];
+    case "leftTop":
+      return [x + width, y + height];
+    case "leftBottom":
+      return [x + width, y];
+    case "rightTop":
+      return [x, y + height];
+    case "rightBottom":
+      return [x, y];
+  }
+}
+function makePlacedBoundsForText({
+  text,
+  fontSize,
+  fontWeight,
+  position,
+  center = false
+}) {
+  const textBounds = Bounds.forText(text, { fontSize, fontWeight });
+  const x = center ? position.x - textBounds.width / 2 : position.x;
+  const y = center ? position.y - textBounds.height / 2 : position.y;
+  return textBounds.set({ x, y });
+}
+function moveExternalLabelIntoOcean({
+  bridgeFeatures,
+  direction,
+  placedBounds,
+  projection,
+  step,
+  maxSteps
+}) {
+  let annotationLabel = makePolygonFromBounds(
+    placedBounds,
+    (position) => projection.invert(position)
+  );
+  let newBounds = placedBounds;
+  for (let tick = 0; tick < maxSteps; tick++) {
+    const intersectsWithSomeFeature = bridgeFeatures.some(
+      (bridgeFeature) => booleanIntersects(annotationLabel, bridgeFeature)
+    );
+    if (!intersectsWithSomeFeature) break;
+    newBounds = newBounds.set(
+      moveIntoDirectionByStep({
+        position: newBounds.topLeft,
+        direction,
+        step
+      })
+    );
+    annotationLabel = makePolygonFromBounds(
+      newBounds,
+      (position) => projection.invert(position)
+    );
+  }
+  return newBounds;
+}
+function moveIntoDirectionByStep({
+  position: { x, y },
+  direction,
+  step
+}) {
+  switch (direction) {
+    case "right":
+      return { x: x + step, y };
+    case "left":
+      return { x: x - step, y };
+    case "top":
+      return { x, y: y - step };
+    case "bottom":
+      return { x, y: y + step };
+    case "leftTop":
+      return { x: x - step, y: y - step };
+    case "rightTop":
+      return { x: x + step, y: y - step };
+    case "leftBottom":
+      return { x: x - step, y: y + step };
+    case "rightBottom":
+      return { x: x + step, y: y + step };
+  }
+}
+const _featuresWithinRadiusCache = /* @__PURE__ */ new Map();
+function getGeoFeaturesWithinRadius(feature) {
+  if (_featuresWithinRadiusCache.has(feature.id))
+    return _featuresWithinRadiusCache.get(feature.id);
+  const circle = {
+    cx: feature.geoCentroid[0],
+    cy: feature.geoCentroid[1],
+    r: 10
+  };
+  const nearbyGeoFeatures = getGeoFeaturesForGlobe().filter(
+    (candidate) => candidate.id !== feature.id && checkRectangleOverlapsWithCircle({
+      circle,
+      rectangle: candidate.geoBounds
+    })
+  ).map((feature2) => feature2.geo);
+  _featuresWithinRadiusCache.set(feature.id, nearbyGeoFeatures);
+  return nearbyGeoFeatures;
+}
+function checkRectangleOverlapsWithCircle({
+  circle,
+  rectangle
+}) {
+  const closestX = R.clamp(circle.cx, {
+    min: rectangle.topLeft.x,
+    max: rectangle.bottomRight.x
+  });
+  const closestY = R.clamp(circle.cy, {
+    min: rectangle.topLeft.y,
+    max: rectangle.bottomRight.y
+  });
+  const dx = circle.cx - closestX;
+  const dy = circle.cy - closestY;
+  return dx * dx + dy * dy <= circle.r * circle.r;
+}
+function minimiseLabelCollisions(annotations, padding = 1) {
+  if (annotations.length < 2) return annotations;
+  const simulationNodes = annotations.map((annotation) => {
+    const { centerX, centerY } = annotation.placedBounds;
+    const isTopOrBottom = annotation.direction === "top" || annotation.direction === "bottom";
+    return {
+      annotation,
+      x: centerX,
+      y: centerY,
+      // fix the x or y position to make sure the simulation doesn't move
+      // a label into its anchor point
+      fx: !isTopOrBottom ? centerX : void 0,
+      fy: isTopOrBottom ? centerY : void 0
+    };
+  });
+  forceSimulation(simulationNodes).force(
+    "x",
+    forceX((d) => d.annotation.placedBounds.centerX)
+  ).force(
+    "y",
+    forceY((d) => d.annotation.placedBounds.centerY)
+  ).force(
+    "collide",
+    bboxCollide((d) => [
+      [
+        -d.annotation.placedBounds.width / 2 - padding,
+        -d.annotation.placedBounds.height / 2 - padding
+      ],
+      [
+        d.annotation.placedBounds.width / 2 + padding,
+        d.annotation.placedBounds.height / 2 + padding
+      ]
+    ]).strength(0.1)
+  ).tick(5);
+  const updatedAnnotations = annotations.map((annotation, index) => {
+    const node = simulationNodes[index];
+    const originalBounds = annotation.placedBounds;
+    const { x: centerX = 0, y: centerY = 0 } = node;
+    const placedBounds = originalBounds.set({
+      x: centerX - originalBounds.width / 2,
+      y: centerY - originalBounds.height / 2
+    });
+    return { ...annotation, placedBounds };
+  });
+  return updatedAnnotations;
+}
+function checkAnnotationCollidesWithLandmass({
+  annotation,
+  nearbyGeoFeatures,
+  projection
+}) {
+  const annotationLabel = makePolygonFromBounds(
+    annotation.placedBounds,
+    (position) => projection.invert(position)
+  );
+  return nearbyGeoFeatures.some(
+    (feature) => booleanIntersects(annotationLabel, feature)
+  );
+}
+function checkAnnotationMarkerCollidesWithSomeLabel({
+  annotation,
+  nearbyAnnotations
+}) {
+  const markerStart = annotation.anchor;
+  const markerEnd = getExternalMarkerEndPosition({
+    textBounds: annotation.placedBounds,
+    direction: annotation.direction
+  });
+  const markerLine = makePolygonForLine(markerStart, markerEnd);
+  return nearbyAnnotations.some((nearbyAnnotation) => {
+    const nearbyLabel = makePolygonFromBounds(nearbyAnnotation.placedBounds);
+    return booleanIntersects(markerLine, nearbyLabel);
+  });
+}
+function makePolygonFromBounds(bounds, transform) {
+  let corners = [
+    [bounds.topLeft.x, bounds.topLeft.y],
+    [bounds.topRight.x, bounds.topRight.y],
+    [bounds.bottomRight.x, bounds.bottomRight.y],
+    [bounds.bottomLeft.x, bounds.bottomLeft.y],
+    [bounds.topLeft.x, bounds.topLeft.y]
+    // close the polygon
+  ];
+  if (transform) {
+    corners = corners.map((position) => transform(position));
+  }
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [corners]
+    }
+  };
+}
+function makePolygonForLine(start, end, lineWidth = 4) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const lineLength = Math.sqrt(dx * dx + dy * dy);
+  const perpX = -dy / lineLength * (lineWidth / 2);
+  const perpY = dx / lineLength * (lineWidth / 2);
+  const corners = [
+    [start[0] + perpX, start[1] + perpY],
+    [start[0] - perpX, start[1] - perpY],
+    [end[0] - perpX, end[1] - perpY],
+    [end[0] + perpX, end[1] + perpY],
+    [start[0] + perpX, start[1] + perpY]
+    // close the polygon
+  ];
+  return {
+    type: "Feature",
+    properties: {},
+    geometry: {
+      type: "Polygon",
+      coordinates: [corners]
+    }
+  };
+}
+export {
+  getExternalMarkerEndPosition,
+  makeExternalAnnotationForFeature,
+  makeInternalAnnotationForFeature,
+  repositionAndFilterExternalAnnotations
+};