@sybilion/uilib 1.2.26 → 1.3.1

package/dist/esm/components/widgets/DriverCard/DriverCard.js

@@ -0,0 +1,89 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import React__default, { useMemo } from 'react';
+import { CoffeeIcon, TrendUpIcon, TrendDownIcon } from '@phosphor-icons/react';
+import { Badge } from '../../ui/Badge/Badge.js';
+import { Card, CardContent } from '../../ui/Card/Card.js';
+import { LabelWithId } from '../../ui/LabelWithId/LabelWithId.js';
+import { Skeleton } from '../../ui/Skeleton/Skeleton.js';
+import { Tooltip, TooltipTrigger, TooltipContent } from '../../ui/Tooltip/Tooltip.js';
+import { getCategoryIcon } from '../DriverMap/driverCategoryIcon.js';
+import S from './DriverCard.styl.js';
+import { DriverPerformanceChart } from './DriverPerformanceChart.js';
+
+function DriverCard({ selectedDriver, isLoading, inQueue = false, driverSelector, }) {
+    const importanceDisplay = useMemo(() => {
+        if (!selectedDriver)
+            return '';
+        let importance = 0;
+        if (selectedDriver.rawImportance &&
+            typeof selectedDriver.rawImportance === 'object') {
+            const importanceObj = selectedDriver.rawImportance;
+            if (importanceObj.overall && typeof importanceObj.overall === 'object') {
+                const overall = importanceObj.overall;
+                if (typeof overall.mean === 'number') {
+                    importance = Math.round(overall.mean);
+                }
+            }
+        }
+        return importance > 0
+            ? `${importance}%`
+            : `${selectedDriver.importance.toFixed(1)}%`;
+    }, [selectedDriver]);
+    const regionDisplay = React__default.useMemo(() => {
+        if (!selectedDriver)
+            return '';
+        // Check for src_region and tgt_region properties first
+        const driver = selectedDriver;
+        const srcRegion = driver.src_region;
+        const tgtRegion = driver.tgt_region;
+        const srcName = srcRegion?.name;
+        const tgtName = tgtRegion?.name;
+        // If both src_region and tgt_region have valid names
+        if (srcName && tgtName) {
+            // If source and target are the same, just show one
+            if (srcName === tgtName) {
+                return srcName;
+            }
+            return `${srcName} → ${tgtName}`;
+        }
+        // If only src_region has a valid name
+        if (srcName) {
+            if (srcName === 'World') {
+                return 'World';
+            }
+            return `${srcName} → World`;
+        }
+        // If only tgt_region has a valid name
+        if (tgtName) {
+            if (tgtName === 'World') {
+                return 'World';
+            }
+            return `World → ${tgtName}`;
+        }
+        if (selectedDriver.region.length === 1)
+            return selectedDriver.region[0];
+        if (selectedDriver.region.length > 1) {
+            return (selectedDriver.region
+                // .filter(region => region !== 'World')
+                .join(' → '));
+        }
+        // Fallback to "World" when no region information is available
+        return 'World';
+    }, [selectedDriver]);
+    if (inQueue) {
+        return (jsx(Card, { className: S.root, children: jsx(CardContent, { centered: true, fullHeight: true, noScroll: true, children: jsxs("div", { className: S.queueMessage, children: [jsx(CoffeeIcon, { size: 24, weight: "regular" }), jsxs("div", { children: [jsx("p", { children: "Retrieving drivers data." }), jsx("p", { children: "This may take a while." })] })] }) }) }));
+    }
+    if (isLoading) {
+        return (jsx(Card, { className: S.root, children: jsx(CardContent, { noScroll: true, children: jsxs("div", { className: S.skeletonContainer, children: [jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.w75}` }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hm} ${S.w50}` }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.w33}` }), jsxs("div", { className: S.skeletonGroup, children: [jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.wFull}` }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.w75}` }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.w50}` })] }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hl} ${S.wFull}` }), jsxs("div", { className: S.skeletonGroup, children: [jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.wFull}` }), jsx(Skeleton, { className: `${S.skeletonItem} ${S.hs} ${S.w75}` })] })] }) }) }));
+    }
+    if (!selectedDriver) {
+        return (jsx(Card, { className: S.root, children: jsx(CardContent, { centered: true, fullHeight: true, noScroll: true, children: jsx("span", { className: S.noDriverSelected, children: "No driver selected" }) }) }));
+    }
+    const { id, name, category, direction, lag, summary } = selectedDriver;
+    const directionText = direction > 0 ? 'Positive' : 'Negative';
+    const DirectionIcon = direction > 0 ? TrendUpIcon : TrendDownIcon;
+    const nameElem = (jsx("h4", { className: `${S.driverTitle} ${S.truncated}`, children: name }));
+    return (jsx(Card, { className: S.root, paddingSize: "l", children: jsx(CardContent, { noScroll: true, children: jsxs("div", { className: S.cardContent, children: [jsx("div", { className: S.driverHeader, children: jsxs("div", { className: S.headerContent, children: [jsxs("div", { className: S.topHeader, children: [jsxs("p", { className: S.categoryInfo, children: [jsx("span", { className: S.categoryIcon, children: getCategoryIcon(category) }), jsx("span", { className: S.categoryText, children: category })] }), driverSelector] }), name.length > 60 ? (jsxs(Tooltip, { children: [jsx(LabelWithId, { id: id, label: jsx(TooltipTrigger, { asChild: true, children: nameElem }) }), jsx(TooltipContent, { side: "left", className: S.tooltipContent, children: jsx("div", { className: S.tooltipTitle, children: name }) })] })) : (jsx(LabelWithId, { id: id, label: nameElem })), jsx("p", { className: S.regionDisplay, children: regionDisplay })] }) }), jsx("div", { className: S.metricsSection, children: jsx("div", { className: S.importanceScore, children: importanceDisplay }) }), jsxs("div", { className: S.directionLagSection, children: [jsxs(Badge, { variant: direction > 0 ? 'green' : 'red', className: S.directionBadge, children: [jsx(DirectionIcon, { className: S.trendIcon }), directionText, " correlation"] }), jsxs("span", { className: S.lagInfo, children: ["Lag: ", lag] })] }), jsx(DriverPerformanceChart, { driver: selectedDriver }), jsx("p", { className: S.description, children: summary ?? '' })] }) }) }));
+}
+
+export { DriverCard };

package/dist/esm/components/widgets/DriverCard/DriverCard.styl.js

@@ -0,0 +1,7 @@
+import styleInject from 'style-inject';
+
+var css_248z = "@media (max-width:768px){:root{--page-x-padding:var(--p-6);--page-y-padding:var(--p-6)}}.DriverCard_root__Kr5Xz{height:auto;min-height:500px;width:100%}@media (min-width:640px){.DriverCard_root__Kr5Xz{min-height:25rem}}@media (min-width:768px){.DriverCard_root__Kr5Xz{min-height:31.25rem}}.DriverCard_cardContent__zB8UV{display:flex;flex-direction:column;gap:.5rem}.DriverCard_noDriverSelected__-mVm-{color:var(--muted-foreground)}.DriverCard_driverHeader__0aeJ-{align-items:flex-start;display:flex;flex-direction:column;gap:.75rem;padding-bottom:.25rem}.DriverCard_headerContent__YNqtK{display:flex;flex-direction:column;flex-grow:1;gap:.5rem;width:100%}.DriverCard_topHeader__sUDUc{align-items:center;display:flex;justify-content:space-between;margin-top:-12px;min-height:36px}.DriverCard_categoryInfo__8Dhqn{align-items:center;color:var(--muted-foreground);display:flex;font-size:.75rem;gap:.25rem}.DriverCard_categoryIcon__lSIM8{color:var(--muted-foreground);height:.75rem;width:.75rem}.DriverCard_categoryText__DuifF{display:-webkit-box;-webkit-line-clamp:1;-webkit-box-orient:vertical;overflow:hidden;text-transform:lowercase}.DriverCard_categoryText__DuifF:first-letter{text-transform:uppercase}.DriverCard_driverTitle__tYQO1{color:var(--foreground);font-size:1.1rem;font-weight:500;line-height:1.4;-webkit-user-select:text;-moz-user-select:text;user-select:text}.DriverCard_driverTitle__tYQO1.DriverCard_truncated__RIn6f{display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical;cursor:help;overflow:hidden}.DriverCard_regionDisplay__QYVWx{color:var(--muted-foreground);font-size:.75rem}.DriverCard_metricsSection__uZViQ{margin-bottom:.5rem;text-align:left}.DriverCard_importanceScore__RGh5Y{align-items:center;color:var(--foreground);display:flex;font-size:2.25rem;font-weight:400;height:auto;line-height:1;-webkit-user-select:text;-moz-user-select:text;user-select:text}.DriverCard_directionLagSection__Mh-ep{align-items:center;display:flex;justify-content:space-between}.DriverCard_directionBadge__7EAHe{align-items:center;display:flex;gap:.5rem}.DriverCard_trendIcon__GtkDe{height:.75rem;width:.75rem}.DriverCard_lagInfo__enbxl{color:var(--muted-foreground);font-size:.75rem}.DriverCard_description__fNR4e{font-size:.875rem;line-height:1.625;-webkit-user-select:text;-moz-user-select:text;user-select:text}.DriverCard_skeletonContainer__AE9MP{display:flex;flex-direction:column;gap:1rem}.DriverCard_skeletonGroup__lQXls{display:flex;flex-direction:column;gap:.5rem}.DriverCard_skeletonItem__pmx4S.DriverCard_hxs__taJow{height:.75rem}.DriverCard_skeletonItem__pmx4S.DriverCard_hs__PlDPB{height:1rem}.DriverCard_skeletonItem__pmx4S.DriverCard_hm__oFwUK{height:2rem}.DriverCard_skeletonItem__pmx4S.DriverCard_hl__McKZn{height:8rem}.DriverCard_skeletonItem__pmx4S.DriverCard_w33__cI-vq{width:33.333333%}.DriverCard_skeletonItem__pmx4S.DriverCard_w50__DcUSo{width:50%}.DriverCard_skeletonItem__pmx4S.DriverCard_w75__To5oR{width:75%}.DriverCard_skeletonItem__pmx4S.DriverCard_w80__y8wQl{width:80%}.DriverCard_skeletonItem__pmx4S.DriverCard_wFull__TnaxF{width:100%}.DriverCard_tooltipContent__F6DUH{font-size:.75rem;max-width:20rem}.DriverCard_tooltipTitle__NieWB{font-family:var(--font-family-body);font-weight:400}.DriverCard_queueMessage__4hQxI{align-items:center;color:var(--muted-foreground);display:flex;flex-direction:column;font-size:.875rem;gap:var(--p-4);line-height:1.5;padding:var(--p-8) var(--p-4);text-align:center}.DriverCard_queueMessage__4hQxI svg{color:var(--muted-foreground);flex-shrink:0;opacity:.8}";
+var S = {"root":"DriverCard_root__Kr5Xz","cardContent":"DriverCard_cardContent__zB8UV","noDriverSelected":"DriverCard_noDriverSelected__-mVm-","driverHeader":"DriverCard_driverHeader__0aeJ-","headerContent":"DriverCard_headerContent__YNqtK","topHeader":"DriverCard_topHeader__sUDUc","categoryInfo":"DriverCard_categoryInfo__8Dhqn","categoryIcon":"DriverCard_categoryIcon__lSIM8","categoryText":"DriverCard_categoryText__DuifF","driverTitle":"DriverCard_driverTitle__tYQO1","truncated":"DriverCard_truncated__RIn6f","regionDisplay":"DriverCard_regionDisplay__QYVWx","metricsSection":"DriverCard_metricsSection__uZViQ","importanceScore":"DriverCard_importanceScore__RGh5Y","directionLagSection":"DriverCard_directionLagSection__Mh-ep","directionBadge":"DriverCard_directionBadge__7EAHe","trendIcon":"DriverCard_trendIcon__GtkDe","lagInfo":"DriverCard_lagInfo__enbxl","description":"DriverCard_description__fNR4e","skeletonContainer":"DriverCard_skeletonContainer__AE9MP","skeletonGroup":"DriverCard_skeletonGroup__lQXls","skeletonItem":"DriverCard_skeletonItem__pmx4S","hxs":"DriverCard_hxs__taJow","hs":"DriverCard_hs__PlDPB","hm":"DriverCard_hm__oFwUK","hl":"DriverCard_hl__McKZn","w33":"DriverCard_w33__cI-vq","w50":"DriverCard_w50__DcUSo","w75":"DriverCard_w75__To5oR","w80":"DriverCard_w80__y8wQl","wFull":"DriverCard_wFull__TnaxF","tooltipContent":"DriverCard_tooltipContent__F6DUH","tooltipTitle":"DriverCard_tooltipTitle__NieWB","queueMessage":"DriverCard_queueMessage__4hQxI"};
+styleInject(css_248z);
+
+export { S as default };

package/dist/esm/components/widgets/DriverCard/DriverPerformanceChart.js

@@ -0,0 +1,83 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import cn from 'classnames';
+import { useMemo } from 'react';
+import { LineChart, CartesianGrid, XAxis, YAxis, Tooltip, Line } from 'recharts';
+import '../../ui/Chart/components/BaseChartWrapper.js';
+import { ChartContainer } from '../../ui/Chart/components/ChartContainer.js';
+import '../../ui/Chart/Chart.context.js';
+import '../../ui/Chart/Chart.styl.js';
+import '../../ui/AnalysisLineIcon/AnalysisLineIcon.styl.js';
+import '@radix-ui/react-slot';
+import '../../ui/Badge/Badge.styl.js';
+import '../../ui/LabelWithId/LabelWithId.styl.js';
+import '@radix-ui/react-select';
+import 'lucide-react';
+import '../../ui/Select/Select.styl.js';
+import '../../ui/TextShimmer/TextShimmer.js';
+import '@phosphor-icons/react';
+import '../../ui/AnalysesSelector/AnalysesSelector.styl.js';
+import '../../ui/Chart/components/CustomChartLegend/CustomChartLegend.styl.js';
+import '../../ui/ChartAreaInteractive/ChartLines.js';
+import '../../ui/Skeleton/Skeleton.styl.js';
+import 'lightweight-charts';
+import '../../ui/Chart/lightweight/LightweightForecastChart.styl.js';
+import { ChartEmptyState } from '../../ui/Chart/components/ChartEmptyState/ChartEmptyState.js';
+import S from './DriverPerformanceChart.styl.js';
+import { generateDriverChartData } from './driverPerformanceChartData.js';
+
+const driverChartConfig = {
+    value: {
+        label: 'Performance',
+        color: 'var(--primary)',
+    },
+};
+function DriverPerformanceChart({ driver, }) {
+    const precision = useMemo(() => {
+        if (!driver.normalized_series)
+            return 7;
+        const values = Object.values(driver.normalized_series).filter((v) => typeof v === 'number' && v !== null);
+        if (values.length === 0)
+            return 7;
+        const absoluteValues = values.map(Math.abs).filter(v => v > 0);
+        if (absoluteValues.length === 0)
+            return 7;
+        const minAbs = Math.min(...absoluteValues);
+        if (minAbs < 0.0001)
+            return 7;
+        if (minAbs < 0.001)
+            return 6;
+        if (minAbs < 0.01)
+            return 5;
+        if (minAbs < 0.1)
+            return 4;
+        if (minAbs < 1)
+            return 3;
+        return 2;
+    }, [driver.normalized_series]);
+    const chartData = useMemo(() => generateDriverChartData(driver, precision), [driver, precision]);
+    const noSeriesData = useMemo(() => {
+        if (!driver.normalized_series)
+            return false;
+        return Object.values(driver.normalized_series).every(value => value === null);
+    }, [driver.normalized_series]);
+    const renderTooltipContent = ({ active, payload, }) => {
+        if (active && payload?.length) {
+            const dataPoint = payload[0];
+            const row = dataPoint?.payload;
+            const date = row?.date;
+            const value = dataPoint?.value;
+            return (jsxs("div", { className: S.chartTooltip, children: [jsx("div", { className: S.tooltipDate, children: date instanceof Date
+                            ? date.toLocaleDateString('en-US', {
+                                month: 'long',
+                                year: 'numeric',
+                            })
+                            : 'Unknown Date' }), jsxs("div", { className: S.tooltipPerformance, children: ["Performance:", ' ', typeof value === 'number'
+                                ? value.toFixed(precision)
+                                : String(value ?? '')] })] }));
+        }
+        return null;
+    };
+    return (jsxs("div", { className: S.driverChartContainer, children: [jsx(ChartContainer, { config: driverChartConfig, className: cn(S.chartContainer, noSeriesData && S.chartContainerDisabled), children: jsxs(LineChart, { data: chartData, margin: { left: 8, right: 8, top: 8, bottom: -20 }, children: [jsx(CartesianGrid, { vertical: false }), jsx(XAxis, { dataKey: "date", tickLine: false, axisLine: false, tick: false, tickMargin: 0, minTickGap: 0 }), jsx(YAxis, { tickLine: false, axisLine: false, tick: false, tickMargin: 0, minTickGap: 0, width: 0, domain: ['dataMin', 'dataMax'] }), jsx(Tooltip, { cursor: false, content: renderTooltipContent }), jsx(Line, { dataKey: "value", type: "natural", stroke: "var(--color-value)" })] }) }), noSeriesData && (jsx(ChartEmptyState, { variant: "inline", align: "center", status: "No series data", className: S.noDataMessage }))] }));
+}
+
+export { DriverPerformanceChart };

package/dist/esm/components/widgets/DriverCard/DriverPerformanceChart.styl.js

@@ -0,0 +1,7 @@
+import styleInject from 'style-inject';
+
+var css_248z = ".DriverPerformanceChart_driverChartContainer__27xZ-{position:relative;width:100%}.DriverPerformanceChart_driverChartContainer__27xZ- svg{overflow:visible}.DriverPerformanceChart_chartContainer__--rGL{height:214px;margin-left:-.5rem;padding:var(--p-4) 0;width:100%}.DriverPerformanceChart_chartContainerDisabled__ndtPZ{opacity:.1}.DriverPerformanceChart_noDataMessage__RO3u1{color:var(--foreground);font-size:.875rem;font-weight:500;left:50%;pointer-events:none;position:absolute;top:50%;transform:translate(-50%,-50%);z-index:10}.DriverPerformanceChart_chartTooltip__cpaQw{background-color:var(--popover);border:1px solid var(--border);border-radius:.5rem;box-shadow:0 10px 15px -3px rgba(0,0,0,.1);padding:.75rem}.DriverPerformanceChart_tooltipDate__B2aeP{color:var(--popover-foreground);font-size:.875rem;font-weight:500}.DriverPerformanceChart_tooltipPerformance__3hfgE{color:var(--muted-foreground);font-size:.875rem}";
+var S = {"driverChartContainer":"DriverPerformanceChart_driverChartContainer__27xZ-","chartContainer":"DriverPerformanceChart_chartContainer__--rGL","chartContainerDisabled":"DriverPerformanceChart_chartContainerDisabled__ndtPZ","noDataMessage":"DriverPerformanceChart_noDataMessage__RO3u1","chartTooltip":"DriverPerformanceChart_chartTooltip__cpaQw","tooltipDate":"DriverPerformanceChart_tooltipDate__B2aeP","tooltipPerformance":"DriverPerformanceChart_tooltipPerformance__3hfgE"};
+styleInject(css_248z);
+
+export { S as default };

package/dist/esm/components/widgets/DriverCard/driverPerformanceChartData.js

@@ -0,0 +1,50 @@
+/** Last non-null points from `normalized_series`, or deterministic fallback sample. */
+function generateDriverChartData(driver, precision = 7) {
+    if (driver.normalized_series) {
+        const entries = Object.entries(driver.normalized_series);
+        const seriesData = entries
+            .filter(([, value]) => value !== null)
+            .map(([date, value]) => {
+            let parsedDate;
+            try {
+                const dateStr = date.toString();
+                if (dateStr.includes('-')) {
+                    parsedDate = new Date(`${dateStr}T00:00:00`);
+                }
+                else {
+                    parsedDate = new Date(dateStr);
+                }
+                if (Number.isNaN(parsedDate.getTime())) {
+                    return null;
+                }
+            }
+            catch {
+                return null;
+            }
+            const numericValue = parseFloat(value.toFixed(precision));
+            return {
+                date: parsedDate,
+                value: numericValue,
+            };
+        })
+            .filter((item) => item !== null)
+            .sort((a, b) => a.date.getTime() - b.date.getTime())
+            .slice(-24);
+        if (seriesData.length > 0) {
+            return seriesData;
+        }
+    }
+    const data = [];
+    const baseValue = driver.importance / 100;
+    for (let i = 0; i < 12; i++) {
+        const randomVariation = (Math.random() - 0.5) * 0.2;
+        const value = Math.max(0, Math.min(1, baseValue + randomVariation));
+        data.push({
+            date: new Date(2023, i, 1),
+            value: parseFloat(value.toFixed(precision)),
+        });
+    }
+    return data;
+}
+
+export { generateDriverChartData };

package/dist/esm/components/widgets/DriverMap/DriverMap.js

@@ -1,13 +1,13 @@
 import { jsxs, jsx } from 'react/jsx-runtime';
 import cn from 'classnames';
 import { useRef, useState, useMemo, useEffect, useCallback } from 'react';
+import { WorldMap } from '../../ui/WorldMap/WorldMap.js';
 import useEvent from '../../../hooks/useEvent.js';
 import { Shimmer } from '@homecode/ui';
 import { DriverIcon } from './DriverIcon/DriverIcon.js';
 import constants from './DriverIcon/DriverIcon.constants.json.js';
 import { findMostSpecificRegion, getDriverCoordinates, hasValidCoords, calculateBadgeSizes } from './DriverMap.helpers.js';
 import S from './DriverMap.styl.js';
-import { MapBackground } from './MapBackground/MapBackground.js';
 import { getHighestImportanceDriver } from './driverMapSelection.js';
 
 const delay = (ms) => new Promise(r => setTimeout(r, ms));
@@ -113,7 +113,7 @@ function DriverMap({ drivers, isLoading, setSelectedDriver, selectedDriver, }) {
         callback: handleKeyDown,
         isCapture: true,
     });
-    return (jsxs("div", { className: cn(S.root, isTransitioning && S.inTransition), children: [jsxs("div", { className: S.mapInner, children: [jsx(MapBackground, {}), isLoading && jsx(Shimmer, { className: S.shimmerOverlay, size: "l" }), otherDrivers.map(driver => (jsx(DriverIcon, { isLoading: isLoading, isVisible: isVisible, driver: driver, size: badgeSizes[driver.id] || 's', isSelected: selectedDriver?.id === driver.id, onClick: () => setSelectedDriver(driver) }, driver.id)))] }), jsx("div", { className: S.worldDrivers, children: worldDrivers.map(driver => {
+    return (jsxs("div", { className: cn(S.root, isTransitioning && S.inTransition), children: [jsxs("div", { className: S.mapInner, children: [jsx(WorldMap, { className: S.mapWorld }), isLoading && jsx(Shimmer, { className: S.shimmerOverlay, size: "l" }), otherDrivers.map(driver => (jsx(DriverIcon, { isLoading: isLoading, isVisible: isVisible, driver: driver, size: badgeSizes[driver.id] || 's', isSelected: selectedDriver?.id === driver.id, onClick: () => setSelectedDriver(driver) }, driver.id)))] }), jsx("div", { className: S.worldDrivers, children: worldDrivers.map(driver => {
                     const driverWithCoords = {
                         ...driver,
                         coordinates: driver.coordinates || {

package/dist/esm/components/widgets/DriverMap/DriverMap.styl.js

@@ -1,7 +1,7 @@
 import styleInject from 'style-inject';
 
-var css_248z = "@media (max-width:768px){:root{--page-x-padding:var(--p-6);--page-y-padding:var(--p-6)}}.DriverMap_root__JszhG{aspect-ratio:623.2/341.276;max-width:100%;overflow:hidden;padding:0;position:relative;width:100%}@media (min-width:768px){.DriverMap_root__JszhG{flex:1;height:35rem;width:-moz-fit-content;width:fit-content}}.DriverMap_mapInner__E7rZR{aspect-ratio:623.2/341.276;border-radius:var(--p-4);margin:0 auto;max-height:100%;max-width:100%;overflow:hidden;position:relative}.DriverMap_shimmerOverlay__UH2qz{z-index:20}.DriverMap_inTransition__lvYwJ{pointer-events:none}.DriverMap_worldDrivers__sZOIW{align-items:center;bottom:0;display:flex;gap:.5rem;padding:.5rem;position:absolute}.DriverMap_worldDrivers__sZOIW button{position:static!important;transform:none!important}.DriverMap_worldDrivers__sZOIW button>span{opacity:1!important;transform:none!important}";
-var S = {"root":"DriverMap_root__JszhG","mapInner":"DriverMap_mapInner__E7rZR","shimmerOverlay":"DriverMap_shimmerOverlay__UH2qz","inTransition":"DriverMap_inTransition__lvYwJ","worldDrivers":"DriverMap_worldDrivers__sZOIW"};
+var css_248z = "@media (max-width:768px){:root{--page-x-padding:var(--p-6);--page-y-padding:var(--p-6)}}.DriverMap_root__JszhG{aspect-ratio:623.2/341.276;max-width:100%;overflow:hidden;padding:0;position:relative;width:100%}@media (min-width:768px){.DriverMap_root__JszhG{flex:1;height:35rem;width:-moz-fit-content;width:fit-content}}.DriverMap_mapInner__E7rZR{aspect-ratio:623.2/341.276;border-radius:var(--p-4);margin:0 auto;max-height:100%;max-width:100%;overflow:hidden;position:relative}.DriverMap_mapWorld__vmPp-{box-sizing:border-box;inset:0;position:absolute}.DriverMap_shimmerOverlay__UH2qz{z-index:20}.DriverMap_inTransition__lvYwJ{pointer-events:none}.DriverMap_worldDrivers__sZOIW{align-items:center;bottom:0;display:flex;gap:.5rem;padding:.5rem;position:absolute}.DriverMap_worldDrivers__sZOIW button{position:static!important;transform:none!important}.DriverMap_worldDrivers__sZOIW button>span{opacity:1!important;transform:none!important}";
+var S = {"root":"DriverMap_root__JszhG","mapInner":"DriverMap_mapInner__E7rZR","mapWorld":"DriverMap_mapWorld__vmPp-","shimmerOverlay":"DriverMap_shimmerOverlay__UH2qz","inTransition":"DriverMap_inTransition__lvYwJ","worldDrivers":"DriverMap_worldDrivers__sZOIW"};
 styleInject(css_248z);
 
 export { S as default };

package/dist/esm/index.js

@@ -81,6 +81,7 @@ export { Toggle } from './components/ui/Toggle/Toggle.js';
 export { ToggleGroup, ToggleGroupItem } from './components/ui/ToggleGroup/ToggleGroup.js';
 export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from './components/ui/Tooltip/Tooltip.js';
 export { VimeoEmbed } from './components/ui/VimeoEmbed/VimeoEmbed.js';
+export { WorldMap } from './components/ui/WorldMap/WorldMap.js';
 export { WorkspaceAppSwitcher } from './components/ui/WorkspaceAppSwitcher/WorkspaceAppSwitcher.js';
 export { WORKSPACE_APP_SLUG_BASE_PATH } from './components/ui/WorkspaceAppSwitcher/workspaceApp.types.js';
 export { WORKSPACE_APPS_LS_KEY } from './components/ui/WorkspaceAppSwitcher/workspaceAppsConstants.js';
@@ -89,12 +90,11 @@ export { WORKSPACE_APP_ICONS, isWorkspaceAppIconKey } from './components/ui/Work
 export { findWorkspaceAppByPathname, workspaceAppSlugPath } from './components/ui/WorkspaceAppSwitcher/workspaceAppPaths.js';
 export { SidebarDatasetsItemsGrouped } from './components/widgets/SidebarDatasetsItemsGrouped/SidebarDatasetsItemsGrouped.js';
 export { groupSidebarDatasets } from './components/widgets/SidebarDatasetsItemsGrouped/groupSidebarDatasets.js';
+export { DriverCard } from './components/widgets/DriverCard/DriverCard.js';
 export { DriverMap } from './components/widgets/DriverMap/DriverMap.js';
 export { getCategoryIcon } from './components/widgets/DriverMap/driverCategoryIcon.js';
 export { getDriverImportance, getHighestImportanceDriver } from './components/widgets/DriverMap/driverMapSelection.js';
 export { geographicCoordinates, geographicToSVG, getContinentFromRegion, getPreciseCoordinates, getResponsiveCoordinates, svgToPercentage } from './components/widgets/DriverMap/driverMapGeography.js';
-export { MapBackground } from './components/widgets/DriverMap/MapBackground/MapBackground.js';
-export { LoadingSpinner } from './components/widgets/DriverMap/LoadingSpinner/LoadingSpinner.js';
 export { SybilionAppHeader } from './components/widgets/SybilionAppHeader/SybilionAppHeader.js';
 export { SybilionAuthLayout } from './components/widgets/SybilionAuthLayout/SybilionAuthLayout.js';
 export { SybilionAuthHeadline } from './components/widgets/SybilionAuthLayout/SybilionAuthHeadline.js';
@@ -103,6 +103,8 @@ export { SignInPage } from './components/widgets/SignInPage/SignInPage.js';
 export { ChartTooltipItem } from './components/ui/Chart/components/ChartTooltipItem.js';
 export { ChartLegendItem } from './components/ui/Chart/components/ChartLegendItem.js';
 export { CustomChartLegend } from './components/ui/Chart/components/CustomChartLegend/CustomChartLegend.js';
+export { LightweightForecastChart } from './components/ui/Chart/lightweight/LightweightForecastChart.js';
+export { ChartEmptyState } from './components/ui/Chart/components/ChartEmptyState/ChartEmptyState.js';
 export { ChartContainer, ChartStyle } from './components/ui/Chart/components/ChartContainer.js';
 export { ChartTooltipContent } from './components/ui/Chart/components/ChartTooltipContent.js';
 export { ChartLegendContent } from './components/ui/Chart/components/ChartLegendContent.js';

package/dist/esm/types/src/components/ui/Chart/Chart.d.ts

@@ -10,3 +10,5 @@ export { ChartTooltipItem } from './components/ChartTooltipItem';
 export { ChartLegendItem } from './components/ChartLegendItem';
 export { CustomChartLegend } from './components/CustomChartLegend/CustomChartLegend';
 export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, ChartStyle, BaseChartWrapper, };
+export { LightweightForecastChart, type LightweightForecastChartProps, } from './lightweight/LightweightForecastChart';
+export { ChartEmptyState, type ChartEmptyStateProps, type ChartEmptyStatusTone, } from './components/ChartEmptyState/ChartEmptyState';

package/dist/esm/types/src/components/ui/Chart/components/BaseChartWrapper.d.ts

@@ -1,8 +1,9 @@
 import { ComponentProps, ReactNode } from 'react';
-import { ChartConfig, ChartContainer } from '#uilib/components/ui/Chart/Chart';
 import type { QuantileBandConfig } from '#uilib/components/ui/Chart/chartForecastVisualization.types';
 import { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
 import { ForecastItemData } from '#uilib/components/ui/ChartAreaInteractive/ChartLines';
+import type { ChartConfig } from '../Chart.types';
+import { ChartContainer } from './ChartContainer';
 import { LegendPayload } from 'recharts/types/component/DefaultLegendContent';
 export interface BaseChartWrapperProps {
     renderId?: string;

package/dist/esm/types/src/components/ui/Chart/components/ChartEmptyState/ChartEmptyState.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export type ChartEmptyStatusTone = 'muted' | 'destructive';
+export interface ChartEmptyStateProps {
+    className?: string;
+    /** Primary guidance (muted). */
+    hint?: ReactNode;
+    /** Status / technical detail. */
+    status?: ReactNode;
+    statusTone?: ChartEmptyStatusTone;
+    /** `panel`: chart-sized block with light fill. `inline`: text only (e.g. above chart). */
+    variant?: 'panel' | 'inline';
+    align?: 'center' | 'start';
+}
+export declare function ChartEmptyState({ className, hint, status, statusTone, variant, align, }: ChartEmptyStateProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chart/lightweight/LightweightForecastChart.d.ts

@@ -0,0 +1,26 @@
+import type { ChartConfig } from '#uilib/components/ui/Chart/Chart.types';
+import type { QuantileBandConfig } from '#uilib/components/ui/Chart/chartForecastVisualization.types';
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+import { ForecastItemData } from '#uilib/components/ui/ChartAreaInteractive/ChartLines';
+export interface LightweightForecastChartProps {
+    chartData: ChartDataPoint[];
+    forecastData?: ForecastItemData[];
+    quantileBands?: QuantileBandConfig[];
+    chartConfig?: ChartConfig;
+    historicalLineColor?: string;
+    isDarkTheme: boolean;
+    height?: number;
+    className?: string;
+    hiddenSeries?: Set<string>;
+    onLegendClick?: (data: unknown, index: number, event: unknown) => void;
+    disableForecastHistoricalBridge?: boolean;
+    forecastLineStyle?: 'dashed' | 'solid';
+    formatDate?: (value: string, detailed?: boolean) => string;
+    formatNumber?: (value: number) => string;
+    loading?: boolean;
+    error?: string | null;
+    noDataMessage?: string;
+    showLegend?: boolean;
+    showTooltip?: boolean;
+}
+export declare function LightweightForecastChart(props: LightweightForecastChartProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/Chart/lightweight/chartTime.d.ts

@@ -0,0 +1,5 @@
+import type { UTCTimestamp } from 'lightweight-charts';
+/**
+ * Parse `YYYY-MM-DD` dates as UTC midnight → Lightweight Charts unix seconds.
+ */
+export declare function chartDateToUtcTimestamp(dateStr: string): UTCTimestamp;

package/dist/esm/types/src/components/ui/Chart/lightweight/lightweightForecastChart.helpers.d.ts

@@ -0,0 +1,13 @@
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+import type { ChartOptions, DeepPartial, LineData, UTCTimestamp } from 'lightweight-charts';
+import type { QuantileBandCustomData } from './quantileBandCustomSeries';
+export declare function buildLightweightChartOptions(args: {
+    isDarkTheme: boolean;
+    width: number;
+    height: number;
+    autoSize?: boolean;
+}): DeepPartial<ChartOptions>;
+export declare function buildHistoricalLineData(rows: ChartDataPoint[]): LineData<UTCTimestamp>[];
+export declare function buildForecastLineData(rows: ChartDataPoint[], forecastKey: string): LineData<UTCTimestamp>[];
+export declare function buildQuantileBandCustomData(rows: ChartDataPoint[], bandKey: string): QuantileBandCustomData[];
+export declare function findNearestChartRow(rows: ChartDataPoint[], time: UTCTimestamp): ChartDataPoint | null;

package/dist/esm/types/src/components/ui/Chart/lightweight/quantileBandCustomSeries.d.ts

@@ -0,0 +1,24 @@
+import type { CustomData, CustomSeriesOptions, CustomSeriesWhitespaceData, ICustomSeriesPaneRenderer, ICustomSeriesPaneView, PaneRendererCustomData, UTCTimestamp } from 'lightweight-charts';
+export interface QuantileBandCustomData extends CustomData<UTCTimestamp> {
+    lower: number;
+    upper: number;
+}
+export type QuantileBandStyle = {
+    fill: string;
+    stroke?: string;
+    strokeWidth: number;
+    strokeDasharray?: string;
+    strokeOpacity?: number;
+};
+export declare class QuantileBandPaneView implements ICustomSeriesPaneView<UTCTimestamp, QuantileBandCustomData, CustomSeriesOptions> {
+    private _paneData;
+    private _style;
+    constructor(initialStyle: QuantileBandStyle);
+    updateStyle(style: QuantileBandStyle): void;
+    renderer(): ICustomSeriesPaneRenderer;
+    update(paneData: PaneRendererCustomData<UTCTimestamp, QuantileBandCustomData>, seriesOptions: CustomSeriesOptions): void;
+    priceValueBuilder(plotRow: QuantileBandCustomData): number[];
+    isWhitespace(data: QuantileBandCustomData | CustomSeriesWhitespaceData<UTCTimestamp>): data is CustomSeriesWhitespaceData<UTCTimestamp>;
+    defaultOptions(): CustomSeriesOptions;
+    destroy(): void;
+}

package/dist/esm/types/src/components/ui/Chart/quantileBandConeChartData.d.ts

@@ -0,0 +1,7 @@
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+/**
+ * Matches ChartAreaInteractive `mode="intervals"`: cone / fan chart hand-off — collapse the
+ * interval to a point at the historical→forecast boundary, then expand along forecast anchors.
+ * (Same rules as `useQuantileBands`, without requiring `ForecastData` — reads tuples from each row.)
+ */
+export declare function applyQuantileBandConeToChartData(chartData: ChartDataPoint[], bandKey: string): ChartDataPoint[];

package/dist/esm/types/src/components/ui/Chart/tools/chartPlotGeometry.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared Recharts plot / margin math (DOM-agnostic except measurement entry points).
+ * Keeps BaseChartWrapper tooltip clamp and ChartAreaInteractive brush in sync.
+ */
+export type ChartMargin = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export declare const DEFAULT_CHART_MARGIN: ChartMargin;
+export declare function resolveChartMargin(margin: Partial<ChartMargin> | undefined): ChartMargin;
+/** Plot box inside `.recharts-wrapper` (Recharts cartesian convention). */
+export declare function getPlotViewBox(wrapper: HTMLElement, m: ChartMargin): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type PlotRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/**
+ * Plot area in `host` local px: prefer painted `.recharts-cartesian-grid`, else
+ * last `.recharts-wrapper` + margins. One `hostRect` read; grid/wrapper rects as needed.
+ */
+export declare function measureHostRelativePlotRect(host: HTMLElement, margin: ChartMargin): PlotRect | null;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/ChartAreaInteractive.d.ts

@@ -1,3 +1,3 @@
 import { ChartAreaInteractiveProps } from './ChartAreaInteractive.types';
 export declare const chartConfig: {};
-export declare function ChartAreaInteractive({ className, chartContainerClassName, legendClassName, xAxisClassName, yAxisClassName, timeRange, onTimeRangeChange, pinMonth, onPinMonthChange, onPreviewMonthChange, chartData, forecastData, error, loading, isDarkTheme, footerActions, mode, selectedForecast, upperQuantiles, lowerQuantiles, selectedLowerQuantile, selectedUpperQuantile, onLowerQuantileChange, onUpperQuantileChange, lowerThreshold, upperThreshold, onLowerThresholdChange, onUpperThresholdChange, discreteThresholdValues, headerActions, excludeLegendIds, loadingAnalyses, onLegendClick, onAnalysisSelect, disableTimeRangeSelector, forecastLineStyle, selectedAnalysisId, chartRenderId, toggleLegendSeries, ensureAnalysisSeriesVisible, overlayForecastData, hiddenSeries, disableForecastHistoricalBridge, ...restProps }: ChartAreaInteractiveProps): import("react/jsx-runtime").JSX.Element;
+export declare function ChartAreaInteractive({ className, chartContainerClassName, legendClassName, xAxisClassName, yAxisClassName, timeRange, onTimeRangeChange, pinMonth, onPinMonthChange, onPreviewMonthChange, chartData, forecastData, error, loading, isDarkTheme, footerActions, mode, selectedForecast, upperQuantiles, lowerQuantiles, selectedLowerQuantile, selectedUpperQuantile, onLowerQuantileChange, onUpperQuantileChange, lowerThreshold, upperThreshold, onLowerThresholdChange, onUpperThresholdChange, discreteThresholdValues, headerActions, excludeLegendIds, loadingAnalyses, onLegendClick, onAnalysisSelect, disableTimeRangeSelector, forecastLineStyle, selectedAnalysisId, chartRenderId, toggleLegendSeries, ensureAnalysisSeriesVisible, overlayForecastData, hiddenSeries, disableForecastHistoricalBridge, overlayElements: overlayElementsProp, ...restProps }: ChartAreaInteractiveProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/ChartAreaInteractive.helpers.d.ts

@@ -8,13 +8,22 @@ declare const timeRangeToMonths: {
     readonly '5y': 60;
     readonly All: 12;
 };
-export type TimeRange = keyof typeof timeRangeToMonths;
+export type TimeRangePreset = keyof typeof timeRangeToMonths;
+/** @deprecated Use `TimeRangePreset` or `string` for brush-encoded ranges. */
+export type TimeRange = TimeRangePreset;
+export declare const DRAG_TIME_RANGE_PREFIX: "__drag:";
+export declare function encodeDragTimeRange(a: Date, b: Date): string;
+export declare function parseDragTimeRange(s: string): {
+    start: Date;
+    end: Date;
+} | null;
+export declare function isTimeRangePreset(s: string): s is TimeRangePreset;
 export type FilterDataForTimeRangeOptions = {
     /** When set (e.g. selected forecast on Forecast tab), the window ends at the
      *  latest point that has shared historical or that analysis — not at another run. */
     endDateAnchorAnalysisId?: number | null;
 };
-export declare const filterDataForTimeRange: (data: ChartDataPoint[], currentTimeRange: TimeRange, options?: FilterDataForTimeRangeOptions) => ChartDataPoint[];
+export declare const filterDataForTimeRange: (data: ChartDataPoint[], currentTimeRange: string, options?: FilterDataForTimeRangeOptions) => ChartDataPoint[];
 export declare const shortDateFormatter: (value: string) => string;
 export declare const longDateFormatter: (value: string) => string;
 /**

package/dist/esm/types/src/components/ui/ChartAreaInteractive/ChartAreaInteractive.types.d.ts

@@ -1,7 +1,6 @@
 import { BaseChartWrapperProps } from '#uilib/components/ui/Chart/components/BaseChartWrapper';
 import type { ForecastData } from '#uilib/types/forecast-data';
 import { LegendPayload } from 'recharts';
-import { TimeRange } from './ChartAreaInteractive.helpers';
 export type OverlayMode = 'pin' | 'intervals' | 'thresholds';
 export interface ChartDataPoint {
     date: string;
@@ -22,7 +21,8 @@ export interface Analysis {
 }
 export interface ChartAreaInteractiveProps extends BaseChartWrapperProps {
     chartContainerClassName?: string;
-    timeRange: TimeRange;
+    /** Preset (`6m`, `1y`, …, `All`) or `__drag:startMs,endMs` from chart brush. */
+    timeRange: string;
     onTimeRangeChange: (range: string) => void;
     pinMonth: string | undefined;
     onPinMonthChange: (month: string | undefined) => void;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/TimeRangeBrushLayer.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from 'react';
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+export interface TimeRangeBrushHostProps {
+    chartData: ChartDataPoint[];
+    onTimeRangeChange: (range: string) => void;
+    enabled: boolean;
+    /** Bumps layout sync when chart remounts (e.g. dataset / render id). */
+    layoutKey?: string | number | null;
+    children: ReactNode;
+}
+/**
+ * Wraps chart; pointerdown on SVG starts horizontal brush. Plot box tracks the
+ * painted grid / Recharts plot (see TimeRangeBrushLayout.helpers).
+ */
+export declare function TimeRangeBrushHost({ chartData, onTimeRangeChange, enabled, layoutKey, children, }: TimeRangeBrushHostProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/TimeRangeBrushLayout.helpers.d.ts

@@ -0,0 +1,14 @@
+import { type ChartMargin, type PlotRect, measureHostRelativePlotRect, resolveChartMargin } from '#uilib/components/ui/Chart/tools/chartPlotGeometry';
+import type { ChartDataPoint } from '#uilib/components/ui/ChartAreaInteractive/ChartAreaInteractive.types';
+/** Debounce for `window` resize only (RO uses rAF-coalesced sync). */
+export declare const BRUSH_LAYOUT_RESIZE_DEBOUNCE_MS = 500;
+export declare const BRUSH_MIN_DRAG_PX = 8;
+export declare const BRUSH_DOUBLE_TAP_MS = 300;
+export declare const BRUSH_DOUBLE_TAP_MAX_DIST_PX = 24;
+export type { ChartMargin };
+export { resolveChartMargin };
+export type BrushPlotLayout = PlotRect;
+/** Host-relative plot rect (grid-first, then wrapper + margins). */
+export declare const measureBrushPlotLayout: typeof measureHostRelativePlotRect;
+export declare function brushPlotLayoutsEqual(a: BrushPlotLayout | null, b: BrushPlotLayout | null): boolean;
+export declare function brushClientXToDate(clientX: number, plotRect: DOMRect, chartData: ChartDataPoint[]): Date | null;

package/dist/esm/types/src/components/ui/ChartAreaInteractive/overlays/PinOverlay/PinOverlay.d.ts

@@ -6,5 +6,5 @@ interface PinOverlayProps {
     onPreviewMonthChange?: (month: string | undefined) => void;
     className?: string;
 }
-export declare function PinOverlay({ baseChartProps, pinMonth, onPinMonthChange, onPreviewMonthChange, className, }: PinOverlayProps): import("react/jsx-runtime").JSX.Element;
+export declare function PinOverlay({ baseChartProps, pinMonth, onPinMonthChange, onPreviewMonthChange: _onPreviewMonthChange, className, }: PinOverlayProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/esm/types/src/components/ui/Page/PageColumns/PageColumns.d.ts

@@ -1,5 +1,5 @@
 export declare function PageColumns({ columns, fill, className, }: {
     columns: React.ReactNode[];
-    fill: 'left' | 'right' | 'all';
+    fill?: 'left' | 'right' | 'all';
     className?: string;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/TimeRangeControls/TimeRangeControls.d.ts

@@ -1,11 +1,9 @@
-import { TimeRange } from './TimeRangeControls.types';
-export declare const TimeRangeControls: import("react").MemoExoticComponent<({ timeRange, onTimeRangeChange, loading, }: {
-    timeRange: TimeRange;
+export type TimeRangeControlsProps = {
+    timeRange: string;
     onTimeRangeChange: (range: string) => void;
     loading?: boolean;
-}) => import("react/jsx-runtime").JSX.Element>;
-export declare const TimeRangeSelect: import("react").MemoExoticComponent<({ timeRange, onTimeRangeChange, loading, }: {
-    timeRange: TimeRange;
-    onTimeRangeChange: (range: string) => void;
+};
+export declare const TimeRangeControls: import("react").MemoExoticComponent<({ timeRange, onTimeRangeChange, loading }: TimeRangeControlsProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const TimeRangeSelect: import("react").MemoExoticComponent<({ timeRange, onTimeRangeChange, loading, }: TimeRangeControlsProps & {
     loading: boolean;
 }) => import("react/jsx-runtime").JSX.Element>;

package/dist/esm/types/src/components/ui/WorldMap/WorldMap.d.ts

@@ -0,0 +1,4 @@
+export type WorldMapProps = {
+    className?: string;
+};
+export declare function WorldMap({ className }: WorldMapProps): import("react/jsx-runtime").JSX.Element;

package/dist/esm/types/src/components/ui/WorldMap/index.d.ts

@@ -0,0 +1,2 @@
+export { WorldMap } from './WorldMap';
+export type { WorldMapProps } from './WorldMap';

package/dist/esm/types/src/components/widgets/DriverCard/DriverCard.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { DriverData } from '../DriverMap/driverMapGeography';
+export interface DriverCardProps {
+    selectedDriver: DriverData | null;
+    isLoading: boolean;
+    inQueue?: boolean;
+    driverSelector?: React.ReactNode;
+}
+export declare function DriverCard({ selectedDriver, isLoading, inQueue, driverSelector, }: DriverCardProps): import("react/jsx-runtime").JSX.Element;