@mui/x-charts-premium 9.8.0 → 9.9.0

package/internals/plugins/useGeoProjectionZoom/gestureHooks/usePanOnDrag.js

@@ -0,0 +1,65 @@
+"use strict";
+'use client';
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePanOnDrag = void 0;
+var React = _interopRequireWildcard(require("react"));
+var _internals = require("@mui/x-charts-pro/internals");
+var _useGeoProjection = require("../../useGeoProjection");
+var _mapZoom = require("../mapZoom.utils");
+const usePanOnDrag = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(_useGeoProjection.selectorChartProjection);
+  const geoPoint = React.useRef(null);
+  const dragStartPoint = React.useRef(null);
+  const dragCurrentPoint = React.useRef(null);
+  (0, _internals.useDragGesture)(instance, {
+    enabled,
+    onPanStart: event => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+      geoPoint.current = projection.invert([event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY]);
+      dragStartPoint.current = [event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY];
+      dragCurrentPoint.current = [event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY];
+    },
+    onPanEnd: () => {
+      geoPoint.current = null;
+      dragStartPoint.current = null;
+      dragCurrentPoint.current = null;
+    },
+    onPan: delta => {
+      if (!projection || dragCurrentPoint.current === null || geoPoint.current === null) {
+        return;
+      }
+      dragCurrentPoint.current = [dragCurrentPoint.current[0] + delta.x, dragCurrentPoint.current[1] + delta.y];
+      const nextRotation = (0, _mapZoom.getRotation)(projection, geoPoint.current, dragCurrentPoint.current, 1, rotationAllowed);
+      const rotate = projection.rotate?.();
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      const translation = (0, _mapZoom.getTranslation)(store, projection, geoPoint.current, dragCurrentPoint.current, translationAllowed, maxEmptySpace);
+      projection.rotate?.(rotate);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: store.state.geoProjectionZoom.zoomLevel ?? 1,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};
+exports.usePanOnDrag = usePanOnDrag;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/usePanOnDrag.mjs

@@ -0,0 +1,58 @@
+'use client';
+
+import * as React from 'react';
+import { useDragGesture } from '@mui/x-charts-pro/internals';
+import { selectorChartProjection } from "../../useGeoProjection/index.mjs";
+import { getRotation, getTranslation } from "../mapZoom.utils.mjs";
+export const usePanOnDrag = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(selectorChartProjection);
+  const geoPoint = React.useRef(null);
+  const dragStartPoint = React.useRef(null);
+  const dragCurrentPoint = React.useRef(null);
+  useDragGesture(instance, {
+    enabled,
+    onPanStart: event => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+      geoPoint.current = projection.invert([event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY]);
+      dragStartPoint.current = [event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY];
+      dragCurrentPoint.current = [event.detail.srcEvent.offsetX, event.detail.srcEvent.offsetY];
+    },
+    onPanEnd: () => {
+      geoPoint.current = null;
+      dragStartPoint.current = null;
+      dragCurrentPoint.current = null;
+    },
+    onPan: delta => {
+      if (!projection || dragCurrentPoint.current === null || geoPoint.current === null) {
+        return;
+      }
+      dragCurrentPoint.current = [dragCurrentPoint.current[0] + delta.x, dragCurrentPoint.current[1] + delta.y];
+      const nextRotation = getRotation(projection, geoPoint.current, dragCurrentPoint.current, 1, rotationAllowed);
+      const rotate = projection.rotate?.();
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      const translation = getTranslation(store, projection, geoPoint.current, dragCurrentPoint.current, translationAllowed, maxEmptySpace);
+      projection.rotate?.(rotate);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: store.state.geoProjectionZoom.zoomLevel ?? 1,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnPinch.d.mts

@@ -0,0 +1,13 @@
+import type { ChartPlugin } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis, MapZoomView, UseGeoProjectionZoomSignature } from "../useGeoProjectionZoom.types.mjs";
+export declare const useZoomOnPinch: ({
+  store,
+  instance
+}: Pick<Parameters<ChartPlugin<UseGeoProjectionZoomSignature>>[0], "store" | "instance">, applyView: (newView: MapZoomView) => void, options: {
+  enabled: boolean;
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+  maxEmptySpace: number;
+  minZoomLevel: number;
+  maxZoomLevel: number;
+}) => void;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnPinch.d.ts

@@ -0,0 +1,13 @@
+import type { ChartPlugin } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis, MapZoomView, UseGeoProjectionZoomSignature } from "../useGeoProjectionZoom.types.js";
+export declare const useZoomOnPinch: ({
+  store,
+  instance
+}: Pick<Parameters<ChartPlugin<UseGeoProjectionZoomSignature>>[0], "store" | "instance">, applyView: (newView: MapZoomView) => void, options: {
+  enabled: boolean;
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+  maxEmptySpace: number;
+  minZoomLevel: number;
+  maxZoomLevel: number;
+}) => void;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnPinch.js

@@ -0,0 +1,62 @@
+"use strict";
+'use client';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useZoomOnPinch = void 0;
+var _internals = require("@mui/x-charts-pro/internals");
+var _useGeoProjection = require("../../useGeoProjection");
+var _mapZoom = require("../mapZoom.utils");
+const useZoomOnPinch = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(_useGeoProjection.selectorChartProjection);
+  const clampZoomLevel = zoomLevel => Math.max(options.minZoomLevel, Math.min(options.maxZoomLevel, zoomLevel));
+  (0, _internals.usePinchGesture)(instance, {
+    enabled,
+    onPinch: (point, deltaScale) => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+
+      // Same clamp-then-derive-factor flow as the wheel, so pinch obeys the identical bounds.
+      const currentZoom = store.state.geoProjectionZoom.zoomLevel ?? 1;
+      const nextZoom = clampZoomLevel(currentZoom * (1 + deltaScale));
+      const factor = nextZoom / currentZoom;
+      if (factor === 1) {
+        return;
+      }
+      const geoPoint = projection.invert([point.x, point.y]);
+      if (!geoPoint) {
+        return;
+      }
+      const nextRotation = (0, _mapZoom.getRotation)(projection, geoPoint, [point.x, point.y], factor, rotationAllowed);
+      const scale = projection.scale();
+      const rotate = projection.rotate?.();
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      projection.scale(scale * factor);
+      const translation = (0, _mapZoom.getTranslation)(store, projection, geoPoint, [point.x, point.y], translationAllowed, maxEmptySpace, store.state.geoProjectionZoom.translation ?? [0, 0]);
+      projection.rotate?.(rotate);
+      projection.scale(scale);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: nextZoom,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};
+exports.useZoomOnPinch = useZoomOnPinch;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnPinch.mjs

@@ -0,0 +1,56 @@
+'use client';
+
+import { usePinchGesture } from '@mui/x-charts-pro/internals';
+import { selectorChartProjection } from "../../useGeoProjection/index.mjs";
+import { getRotation, getTranslation } from "../mapZoom.utils.mjs";
+export const useZoomOnPinch = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(selectorChartProjection);
+  const clampZoomLevel = zoomLevel => Math.max(options.minZoomLevel, Math.min(options.maxZoomLevel, zoomLevel));
+  usePinchGesture(instance, {
+    enabled,
+    onPinch: (point, deltaScale) => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+
+      // Same clamp-then-derive-factor flow as the wheel, so pinch obeys the identical bounds.
+      const currentZoom = store.state.geoProjectionZoom.zoomLevel ?? 1;
+      const nextZoom = clampZoomLevel(currentZoom * (1 + deltaScale));
+      const factor = nextZoom / currentZoom;
+      if (factor === 1) {
+        return;
+      }
+      const geoPoint = projection.invert([point.x, point.y]);
+      if (!geoPoint) {
+        return;
+      }
+      const nextRotation = getRotation(projection, geoPoint, [point.x, point.y], factor, rotationAllowed);
+      const scale = projection.scale();
+      const rotate = projection.rotate?.();
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      projection.scale(scale * factor);
+      const translation = getTranslation(store, projection, geoPoint, [point.x, point.y], translationAllowed, maxEmptySpace, store.state.geoProjectionZoom.translation ?? [0, 0]);
+      projection.rotate?.(rotate);
+      projection.scale(scale);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: nextZoom,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnWheel.d.mts

@@ -0,0 +1,13 @@
+import type { ChartPlugin } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis, MapZoomView, UseGeoProjectionZoomSignature } from "../useGeoProjectionZoom.types.mjs";
+export declare const useZoomOnWheel: ({
+  store,
+  instance
+}: Pick<Parameters<ChartPlugin<UseGeoProjectionZoomSignature>>[0], "store" | "instance">, applyView: (newView: MapZoomView) => void, options: {
+  enabled: boolean;
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+  maxEmptySpace: number;
+  minZoomLevel: number;
+  maxZoomLevel: number;
+}) => void;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnWheel.d.ts

@@ -0,0 +1,13 @@
+import type { ChartPlugin } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis, MapZoomView, UseGeoProjectionZoomSignature } from "../useGeoProjectionZoom.types.js";
+export declare const useZoomOnWheel: ({
+  store,
+  instance
+}: Pick<Parameters<ChartPlugin<UseGeoProjectionZoomSignature>>[0], "store" | "instance">, applyView: (newView: MapZoomView) => void, options: {
+  enabled: boolean;
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+  maxEmptySpace: number;
+  minZoomLevel: number;
+  maxZoomLevel: number;
+}) => void;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnWheel.js

@@ -0,0 +1,64 @@
+"use strict";
+'use client';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useZoomOnWheel = void 0;
+var _internals = require("@mui/x-charts-pro/internals");
+var _useGeoProjection = require("../../useGeoProjection");
+var _mapZoom = require("../mapZoom.utils");
+const useZoomOnWheel = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(_useGeoProjection.selectorChartProjection);
+  const clampZoomLevel = zoomLevel => Math.max(options.minZoomLevel, Math.min(options.maxZoomLevel, zoomLevel));
+  (0, _internals.useWheelGesture)(instance, {
+    enabled,
+    onWheel: (point, event) => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+
+      // Clamp the target zoom first, then derive the factor actually applied. At the bounds the
+      // factor collapses to `1`, so wheeling further neither scales nor shifts the map.
+      const currentZoom = store.state.geoProjectionZoom.zoomLevel ?? 1;
+      const rawFactor = event.deltaY < 0 ? _mapZoom.WHEEL_ZOOM_STEP : 1 / _mapZoom.WHEEL_ZOOM_STEP;
+      const nextZoom = clampZoomLevel(currentZoom * rawFactor);
+      const factor = nextZoom / currentZoom;
+      if (factor === 1) {
+        return;
+      }
+      const geoPoint = projection.invert([point.x, point.y]);
+      if (!geoPoint) {
+        return;
+      }
+      const rotate = projection.rotate?.();
+      const scale = projection.scale();
+      const nextRotation = (0, _mapZoom.getRotation)(projection, geoPoint, [point.x, point.y], factor, rotationAllowed);
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      projection.scale(scale * factor);
+      const translation = (0, _mapZoom.getTranslation)(store, projection, geoPoint, [point.x, point.y], translationAllowed, maxEmptySpace);
+      projection.rotate?.(rotate);
+      projection.scale(scale);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: nextZoom,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};
+exports.useZoomOnWheel = useZoomOnWheel;

package/internals/plugins/useGeoProjectionZoom/gestureHooks/useZoomOnWheel.mjs

@@ -0,0 +1,58 @@
+'use client';
+
+import { useWheelGesture } from '@mui/x-charts-pro/internals';
+import { selectorChartProjection } from "../../useGeoProjection/index.mjs";
+import { getRotation, getTranslation, WHEEL_ZOOM_STEP } from "../mapZoom.utils.mjs";
+export const useZoomOnWheel = ({
+  store,
+  instance
+}, applyView, options) => {
+  const {
+    enabled,
+    rotationAllowed,
+    translationAllowed,
+    maxEmptySpace
+  } = options;
+  const projection = store.use(selectorChartProjection);
+  const clampZoomLevel = zoomLevel => Math.max(options.minZoomLevel, Math.min(options.maxZoomLevel, zoomLevel));
+  useWheelGesture(instance, {
+    enabled,
+    onWheel: (point, event) => {
+      if (!projection || !projection.invert) {
+        return;
+      }
+
+      // Clamp the target zoom first, then derive the factor actually applied. At the bounds the
+      // factor collapses to `1`, so wheeling further neither scales nor shifts the map.
+      const currentZoom = store.state.geoProjectionZoom.zoomLevel ?? 1;
+      const rawFactor = event.deltaY < 0 ? WHEEL_ZOOM_STEP : 1 / WHEEL_ZOOM_STEP;
+      const nextZoom = clampZoomLevel(currentZoom * rawFactor);
+      const factor = nextZoom / currentZoom;
+      if (factor === 1) {
+        return;
+      }
+      const geoPoint = projection.invert([point.x, point.y]);
+      if (!geoPoint) {
+        return;
+      }
+      const rotate = projection.rotate?.();
+      const scale = projection.scale();
+      const nextRotation = getRotation(projection, geoPoint, [point.x, point.y], factor, rotationAllowed);
+      if (nextRotation) {
+        projection.rotate?.([-nextRotation[0], -nextRotation[1], nextRotation[2]]);
+      }
+      projection.scale(scale * factor);
+      const translation = getTranslation(store, projection, geoPoint, [point.x, point.y], translationAllowed, maxEmptySpace);
+      projection.rotate?.(rotate);
+      projection.scale(scale);
+      if (nextRotation || translation) {
+        applyView({
+          zoomLevel: nextZoom,
+          center: nextRotation ? [nextRotation[0], nextRotation[1]] : store.state.geoProjectionZoom.center ?? [0, 0],
+          translation: translation ?? store.state.geoProjectionZoom.translation ?? [0, 0],
+          roll: nextRotation ? nextRotation[2] : store.state.geoProjectionZoom.roll ?? 0
+        });
+      }
+    }
+  });
+};

package/internals/plugins/useGeoProjectionZoom/index.d.mts

@@ -0,0 +1,2 @@
+export { useGeoProjectionZoom } from "./useGeoProjectionZoom.mjs";
+export type { UseGeoProjectionZoomSignature, MapZoomView } from "./useGeoProjectionZoom.types.mjs";

package/internals/plugins/useGeoProjectionZoom/index.d.ts

@@ -0,0 +1,2 @@
+export { useGeoProjectionZoom } from "./useGeoProjectionZoom.js";
+export type { UseGeoProjectionZoomSignature, MapZoomView } from "./useGeoProjectionZoom.types.js";

package/internals/plugins/useGeoProjectionZoom/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "useGeoProjectionZoom", {
+  enumerable: true,
+  get: function () {
+    return _useGeoProjectionZoom.useGeoProjectionZoom;
+  }
+});
+var _useGeoProjectionZoom = require("./useGeoProjectionZoom");

package/internals/plugins/useGeoProjectionZoom/index.mjs

@@ -0,0 +1 @@
+export { useGeoProjectionZoom } from "./useGeoProjectionZoom.mjs";

package/internals/plugins/useGeoProjectionZoom/mapZoom.utils.d.mts

@@ -0,0 +1,31 @@
+import type { GeoProjection } from '@mui/x-charts-vendor/d3-geo';
+import type { ChartUsedStore } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis } from "./useGeoProjectionZoom.types.mjs";
+import type { GeoProjectionInput } from "../useGeoProjection/index.mjs";
+/** Multiplicative zoom step applied per wheel tick. */
+export declare const WHEEL_ZOOM_STEP = 1.1;
+/** Multiplicative zoom step applied per `zoomIn`/`zoomOut` call. */
+export declare const BUTTON_ZOOM_STEP = 1.3;
+type ProjectionFamily = 'azimuthal' | 'conic' | 'cylindrical' | 'albersUsa';
+export declare function getProjectionFamily(projection: GeoProjectionInput | null): ProjectionFamily;
+export declare function getDefaultMapInteraction(projection: GeoProjectionInput | null): {
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+};
+/**
+ * For a given projection, apply a zoom factor to the scale and return the rotation that renders
+ * `geoPoint` at the `to` pixel coordinates, as `[longitude, latitude, roll]` (the view `center` plus
+ * the third d3 rotation angle).
+ *
+ * - With `rotationAllowed: 'both+roll'`, the roll is free to move but kept as stable as possible: the
+ *   shortest-arc rotation dragging `geoPoint` onto `to` is composed with the current orientation, so
+ *   the roll only drifts as much as strictly required.
+ * - With `rotationAllowed: 'both'`, both longitude and latitude are free but the roll is kept fixed at
+ *   the current value.
+ * - With `rotationAllowed: 'longitude'`, only the longitude is solved; the latitude and roll are kept fixed.
+ * - With `rotationAllowed: 'none'`, `null` is returned so the caller keeps the current rotation.
+ */
+export declare function getRotation(projection: GeoProjection, geoPoint: [number, number], to: [number, number], zoomFactor?: number, rotationAllowed?: MapRotationAxis): [number, number, number] | null;
+export declare function clampTranslationAxis(value: number, init: number, boundingBox0: number, boundingBox1: number, areaStart: number, areaEnd: number, gap: number): number;
+export declare function getTranslation(store: ChartUsedStore<any>, projection: GeoProjection, geoPoint: [number, number], to: [number, number], translationAllowed?: MapTranslationAxis, maxEmptySpace?: number, currentTranslation?: [number, number]): [number, number] | null;
+export {};

package/internals/plugins/useGeoProjectionZoom/mapZoom.utils.d.ts

@@ -0,0 +1,31 @@
+import type { GeoProjection } from '@mui/x-charts-vendor/d3-geo';
+import type { ChartUsedStore } from '@mui/x-charts/internals';
+import type { MapRotationAxis, MapTranslationAxis } from "./useGeoProjectionZoom.types.js";
+import type { GeoProjectionInput } from "../useGeoProjection/index.js";
+/** Multiplicative zoom step applied per wheel tick. */
+export declare const WHEEL_ZOOM_STEP = 1.1;
+/** Multiplicative zoom step applied per `zoomIn`/`zoomOut` call. */
+export declare const BUTTON_ZOOM_STEP = 1.3;
+type ProjectionFamily = 'azimuthal' | 'conic' | 'cylindrical' | 'albersUsa';
+export declare function getProjectionFamily(projection: GeoProjectionInput | null): ProjectionFamily;
+export declare function getDefaultMapInteraction(projection: GeoProjectionInput | null): {
+  rotationAllowed: MapRotationAxis;
+  translationAllowed: MapTranslationAxis;
+};
+/**
+ * For a given projection, apply a zoom factor to the scale and return the rotation that renders
+ * `geoPoint` at the `to` pixel coordinates, as `[longitude, latitude, roll]` (the view `center` plus
+ * the third d3 rotation angle).
+ *
+ * - With `rotationAllowed: 'both+roll'`, the roll is free to move but kept as stable as possible: the
+ *   shortest-arc rotation dragging `geoPoint` onto `to` is composed with the current orientation, so
+ *   the roll only drifts as much as strictly required.
+ * - With `rotationAllowed: 'both'`, both longitude and latitude are free but the roll is kept fixed at
+ *   the current value.
+ * - With `rotationAllowed: 'longitude'`, only the longitude is solved; the latitude and roll are kept fixed.
+ * - With `rotationAllowed: 'none'`, `null` is returned so the caller keeps the current rotation.
+ */
+export declare function getRotation(projection: GeoProjection, geoPoint: [number, number], to: [number, number], zoomFactor?: number, rotationAllowed?: MapRotationAxis): [number, number, number] | null;
+export declare function clampTranslationAxis(value: number, init: number, boundingBox0: number, boundingBox1: number, areaStart: number, areaEnd: number, gap: number): number;
+export declare function getTranslation(store: ChartUsedStore<any>, projection: GeoProjection, geoPoint: [number, number], to: [number, number], translationAllowed?: MapTranslationAxis, maxEmptySpace?: number, currentTranslation?: [number, number]): [number, number] | null;
+export {};