react-native-mapsforge-vtm-ext-grib 0.2.0

package/src/reanimated/useWeatherAnimation.ts

@@ -0,0 +1,118 @@
+import { useCallback, useMemo } from 'react';
+import {
+	useSharedValue,
+	withTiming,
+	type SharedValue,
+} from 'react-native-reanimated';
+
+export interface WeatherAnimationControls {
+	/** The current animation progress (0.0 to timeSteps.length - 1). */
+	progressSv: SharedValue<number>;
+	/** Start playing the animation. */
+	play: () => void;
+	/** Pause the animation. */
+	pause: () => void;
+	/** Reset to the first time step. */
+	reset: () => void;
+	/** Seek to a specific time step index (fractional for interpolation). */
+	seek: (timeIndex: number) => void;
+}
+
+/**
+ * Creates a reanimated shared value that drives smooth time-step animation
+ * for a weather overlay.
+ *
+ * The progress value ranges from 0.0 to (numTimeSteps - 1), where the
+ * fractional part represents the interpolation between adjacent time steps.
+ *
+ * Usage with WeatherOverlay:
+ * - Pass `Math.floor(progress.value)` as `timeIndex` to the "current" layer
+ * - Pass `Math.ceil(progress.value)` as `timeIndex` to the "next" layer
+ * - Set the "next" layer's opacity to `progress.value - Math.floor(progress.value)`
+ *
+ * @param numTimeSteps - Total number of forecast time steps available.
+ * @param durationMs - Duration of the full animation in milliseconds.
+ * @returns Animation controls including the progress shared value.
+ *
+ * @example
+ * ```tsx
+ * const { progressSv, play, pause } = useWeatherAnimation(
+ *   weatherData.timeSteps.length,
+ *   10000
+ * );
+ *
+ * // In a worklet or useDerivedValue:
+ * const currentIdx = Math.floor(progressSv.value);
+ * const nextAlpha = progressSv.value - currentIdx;
+ * ```
+ */
+export function useWeatherAnimation(
+	numTimeSteps: number,
+	durationMs: number = 10000
+): WeatherAnimationControls {
+	const progressSv = useSharedValue<number>(0);
+	const isPlayingSv = useSharedValue<boolean>(false);
+
+	const play = useCallback(() => {
+		'worklet';
+		if (isPlayingSv.value) return;
+		isPlayingSv.value = true;
+
+		// Calculate remaining duration based on current progress
+		const remainingProgress = numTimeSteps - 1 - progressSv.value;
+		const remainingDuration = Math.max(
+			100,
+			(remainingProgress / (numTimeSteps - 1)) * durationMs
+		);
+
+		progressSv.value = withTiming(
+			numTimeSteps - 1,
+			{ duration: Math.round(remainingDuration) },
+			(finished) => {
+				if (finished) {
+					isPlayingSv.value = false;
+				}
+			}
+		);
+	}, [
+		numTimeSteps,
+		durationMs,
+		progressSv,
+		isPlayingSv,
+	]);
+
+	const pause = useCallback(() => {
+		'worklet';
+		isPlayingSv.value = false;
+		// Cancel the current timing by setting to current value
+		progressSv.value = progressSv.value;
+	}, [progressSv, isPlayingSv]);
+
+	const reset = useCallback(() => {
+		'worklet';
+		isPlayingSv.value = false;
+		progressSv.value = 0;
+	}, [progressSv, isPlayingSv]);
+
+	const seek = useCallback(
+		(timeIndex: number) => {
+			'worklet';
+			const clamped = Math.max(0, Math.min(numTimeSteps - 1, timeIndex));
+			progressSv.value = clamped;
+		},
+		[numTimeSteps, progressSv]
+	);
+
+	return useMemo(
+		() => ({ progressSv, play, pause, reset, seek }),
+		[
+			progressSv,
+			play,
+			pause,
+			reset,
+			seek,
+		]
+	);
+}
+
+export default useWeatherAnimation;

package/src/reportNativeError.ts

@@ -0,0 +1,15 @@
+import type { ErrorBase } from './types';
+
+export default function reportNativeError(
+	err: ErrorBase,
+	onError?: null | ((err: ErrorBase) => void)
+): void {
+	if (onError) {
+		onError(err);
+	} else if (__DEV__) {
+		console.warn(
+			'[react-native-mapsforge-vtm-ext-grib]',
+			err?.userInfo?.errorMsg ?? 'Unknown native error'
+		);
+	}
+}

package/src/types.ts

@@ -0,0 +1,56 @@
+/**
+ * Base types shared across the ext-grib library.
+ *
+ * Mirrors the pattern from react-native-mapsforge-vtm's types.ts.
+ */
+
+export interface ResponseBase {
+	uuid: string;
+	nativeNodeHandle: number;
+}
+
+export interface ErrorBase {
+	userInfo?: {
+		errorMsg?: string;
+	};
+}
+
+/**
+ * Represents one time step of gridded weather data.
+ * This is the format produced by server-side GRIB to JSON conversion
+ * (and later by on-device JGribX parsing).
+ */
+export interface WeatherGrid {
+	/** UTC ISO timestamp e.g. "2026-07-03T00:00:00Z" */
+	validTime: string;
+	/** Minimum latitude of the grid (southern edge) */
+	minLat: number;
+	/** Maximum latitude of the grid (northern edge) */
+	maxLat: number;
+	/** Minimum longitude of the grid (western edge) */
+	minLng: number;
+	/** Maximum longitude of the grid (eastern edge) */
+	maxLng: number;
+	/** Number of grid points in the longitude direction */
+	ni: number;
+	/** Number of grid points in the latitude direction */
+	nj: number;
+	/** Row-major grid values, length = ni * nj. Missing values are NaN. */
+	values: number[];
+}
+
+/**
+ * Metadata for a weather data source (returned after loading).
+ */
+export interface WeatherMetadata {
+	parameter: string;
+	levelType?: string;
+	unit: string;
+	timeSteps: WeatherGrid[];
+}
+
+/**
+ * Built-in color ramp identifiers.
+ */
+export type ColorMapName =
+	'temperature' | 'wind' | 'pressure' | 'rainfall' | 'waves' | 'grayscale';