@maydon_tech/react-native-nitro-maps 0.1.4 → 0.2.0

package/src/types/theme.ts

@@ -0,0 +1,101 @@
+import type { MapStyle } from './map';
+
+// ============ Provider-Specific Theme Types ============
+
+/**
+ * Google Maps theme — JSON-based styling.
+ * Array of style elements targeting map features with visual modifiers.
+ *
+ * @see https://mapstyle.withgoogle.com/
+ * @see https://developers.google.com/maps/documentation/javascript/style-reference
+ *
+ * @example
+ * ```ts
+ * const darkTheme: GoogleMapTheme = [
+ *   { featureType: 'water', stylers: [{ color: '#0e171d' }] },
+ *   { featureType: 'road', stylers: [{ visibility: 'simplified' }] },
+ * ];
+ * ```
+ */
+export type GoogleMapTheme = MapStyle;
+
+/**
+ * Apple Maps theme — configuration-based styling.
+ *
+ * Maps to `MKMapConfiguration` on iOS. Unlike Google's element-level JSON
+ * styling, Apple Maps uses high-level configuration categories.
+ *
+ * **Not yet implemented** — will be available when the Apple Maps provider
+ * is added (Phase 3).
+ *
+ * @example
+ * ```ts
+ * const appleTheme: AppleMapTheme = {
+ *   colorScheme: 'dark',
+ *   emphasisStyle: 'muted',
+ *   showsTraffic: true,
+ *   pointOfInterestFilter: {
+ *     includes: ['restaurant', 'cafe', 'hotel'],
+ *   },
+ * };
+ * ```
+ */
+export type AppleMapTheme = {
+  /** Color scheme for the map. @default 'light' */
+  colorScheme?: 'light' | 'dark';
+  /** Emphasis style — 'muted' reduces visual clutter. @default 'default' */
+  emphasisStyle?: 'default' | 'muted';
+  /** Show real-time traffic overlay. @default false */
+  showsTraffic?: boolean;
+  /** Filter which points of interest are visible. */
+  pointOfInterestFilter?: {
+    /** Only show these POI categories. Mutually exclusive with `excludes`. */
+    includes?: string[];
+    /** Hide these POI categories. Mutually exclusive with `includes`. */
+    excludes?: string[];
+  };
+};
+
+/**
+ * Yandex Maps theme — style URI or night mode toggle.
+ *
+ * **Not yet implemented** — will be available when the Yandex Maps provider
+ * is added (Phase 4).
+ *
+ * @example
+ * ```ts
+ * const yandexTheme: YandexMapTheme = {
+ *   nightModeEnabled: true,
+ * };
+ * ```
+ */
+export type YandexMapTheme = {
+  /** Custom style URI (e.g., from Yandex Style Editor). */
+  styleUri?: string;
+  /** Enable built-in night/dark mode. @default false */
+  nightModeEnabled?: boolean;
+};
+
+// ============ Provider → Theme Mapping ============
+
+/**
+ * Maps each provider to its theme type.
+ * Used by the generic `NitroMapProps<P>` to enforce type-safe themes.
+ *
+ * When you write `<NitroMap provider="google" theme={...} />`,
+ * TypeScript narrows `theme` to `GoogleMapTheme`.
+ *
+ * When you write `<NitroMap provider="apple" theme={...} />`,
+ * TypeScript narrows `theme` to `AppleMapTheme`.
+ */
+export type ThemeForProvider = {
+  google: GoogleMapTheme;
+  apple: AppleMapTheme;
+  yandex: YandexMapTheme;
+};
+
+/**
+ * Union of all possible theme types.
+ * Use `ThemeForProvider[P]` for type-safe narrowing instead.
+ */
+export type MapTheme = GoogleMapTheme | AppleMapTheme | YandexMapTheme;

package/src/utils/colors.ts

@@ -53,21 +53,6 @@ export const parseColor = (
   return undefined;
 };
 
-/**
- * Parse a ColorValue with a fallback default color
- * @param color - Color value (hex string or MarkerColor)
- * @param fallback - Fallback MarkerColor if parsing fails
- * @returns MarkerColor object
- * @internal
- */
-export const parseColorWithFallback = (
-  color: ColorValue | undefined,
-  fallback: MarkerColor
-): MarkerColor => {
-  const parsed = parseColor(color);
-  return parsed ?? fallback;
-};
-
 /**
  * Create a MarkerColor from RGB values
  * @param r - Red component (0-255)
@@ -106,7 +91,20 @@ export const rgb = (
  * ```
  */
 export const hex = (hexStr: string, alpha: number = 255): MarkerColor => {
-  // Try 6-char hex first (#RRGGBB or RRGGBB)
+  // Try 8-char hex first (#RRGGBBAA or RRGGBBAA)
+  const result8 = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(
+    hexStr
+  );
+  if (result8) {
+    return {
+      r: parseInt(result8[1]!, 16),
+      g: parseInt(result8[2]!, 16),
+      b: parseInt(result8[3]!, 16),
+      a: parseInt(result8[4]!, 16),
+    };
+  }
+
+  // Try 6-char hex (#RRGGBB or RRGGBB)
   const result6 = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hexStr);
   if (result6) {
     return {
@@ -117,6 +115,17 @@ export const hex = (hexStr: string, alpha: number = 255): MarkerColor => {
     };
   }
 
+  // Try 4-char hex (#RGBA or RGBA)
+  const result4 = /^#?([a-f\d])([a-f\d])([a-f\d])([a-f\d])$/i.exec(hexStr);
+  if (result4) {
+    return {
+      r: parseInt(result4[1]! + result4[1]!, 16),
+      g: parseInt(result4[2]! + result4[2]!, 16),
+      b: parseInt(result4[3]! + result4[3]!, 16),
+      a: parseInt(result4[4]! + result4[4]!, 16),
+    };
+  }
+
   // Try 3-char hex (#RGB or RGB)
   const result3 = /^#?([a-f\d])([a-f\d])([a-f\d])$/i.exec(hexStr);
   if (result3) {
@@ -129,6 +138,11 @@ export const hex = (hexStr: string, alpha: number = 255): MarkerColor => {
   }
 
   // Fallback to black
+  if (__DEV__) {
+    console.warn(
+      `hex(): invalid hex color string "${hexStr}". Falling back to black.`
+    );
+  }
   return { r: 0, g: 0, b: 0, a: alpha };
 };
 
@@ -157,3 +171,21 @@ export const Colors = {
   /** Light gray (240, 240, 240) */
   lightGray: rgb(240, 240, 240),
 };
+
+/**
+ * Compare two ColorValue values for equality.
+ * Handles both hex strings and MarkerColor objects.
+ * @internal Used by component memo comparators to avoid duplication.
+ */
+export const areColorsEqual = (
+  a: ColorValue | undefined,
+  b: ColorValue | undefined
+): boolean => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (typeof a !== typeof b) return false;
+  if (typeof a === 'string' && typeof b === 'string') return a === b;
+  const ca = a as MarkerColor;
+  const cb = b as MarkerColor;
+  return ca.r === cb.r && ca.g === cb.g && ca.b === cb.b && ca.a === cb.a;
+};

package/src/utils/validation.ts

@@ -0,0 +1,69 @@
+// src/utils/validation.ts
+
+import type { Coordinate } from '../types/map';
+
+/**
+ * Validate a coordinate in __DEV__ mode.
+ * Warns on NaN, Infinity, or out-of-range values.
+ */
+export function validateCoordinate(
+  coordinate: Coordinate,
+  context: string
+): void {
+  if (!__DEV__) return;
+
+  const { latitude, longitude } = coordinate;
+
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    console.warn(
+      `[NitroMap] Invalid coordinate in ${context}: ` +
+        `latitude=${latitude}, longitude=${longitude}. ` +
+        'Coordinates must be finite numbers.'
+    );
+    return;
+  }
+
+  if (latitude < -90 || latitude > 90) {
+    console.warn(
+      `[NitroMap] Out-of-range latitude in ${context}: ${latitude}. ` +
+        'Latitude must be between -90 and 90.'
+    );
+  }
+
+  if (longitude < -180 || longitude > 180) {
+    console.warn(
+      `[NitroMap] Out-of-range longitude in ${context}: ${longitude}. ` +
+        'Longitude must be between -180 and 180.'
+    );
+  }
+}
+
+/**
+ * Validate an array of coordinates in __DEV__ mode.
+ * Only reports the first invalid coordinate to avoid console spam.
+ */
+export function validateCoordinates(
+  coordinates: Coordinate[],
+  context: string
+): void {
+  if (!__DEV__) return;
+
+  for (let i = 0; i < coordinates.length; i++) {
+    const coord = coordinates[i]!;
+    const { latitude, longitude } = coord;
+    if (
+      !Number.isFinite(latitude) ||
+      !Number.isFinite(longitude) ||
+      latitude < -90 ||
+      latitude > 90 ||
+      longitude < -180 ||
+      longitude > 180
+    ) {
+      console.warn(
+        `[NitroMap] Invalid coordinate at index ${i} in ${context}: ` +
+          `latitude=${latitude}, longitude=${longitude}.`
+      );
+      return; // report first invalid only
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/nitromap/ClusterIconGenerator.kt

@@ -1,108 +0,0 @@
-package com.margelo.nitro.nitromap
-
-import android.content.Context
-import android.graphics.*
-import com.google.android.gms.maps.model.BitmapDescriptor
-import com.google.android.gms.maps.model.BitmapDescriptorFactory
-import kotlin.math.roundToInt
-import androidx.core.graphics.toColorInt
-
-/**
- * Generator for cluster marker icons
- */
-class ClusterIconGenerator(private val context: Context) {
-
-    private var backgroundColor = "#007AFF".toColorInt() // iOS blue
-    private var textColor = Color.WHITE
-    private var borderColor = Color.WHITE
-    private var borderWidth = 2f
-
-    private val iconCache = mutableMapOf<Int, BitmapDescriptor>()
-
-    fun updateConfig(config: ClusterConfig?) {
-        config?.let {
-            backgroundColor = ColorUtils.fromColorValue(it.backgroundColor)
-            textColor = ColorUtils.fromColorValue(it.textColor)
-            borderColor = ColorUtils.fromColorValue(it.borderColor)
-            borderWidth = it.borderWidth.toFloat()
-            // Clear cache when config changes
-            iconCache.clear()
-        }
-    }
-
-    fun getClusterIcon(count: Int): BitmapDescriptor {
-        // Check cache first
-        iconCache[count]?.let { return it }
-
-        val density = context.resources.displayMetrics.density
-
-        // Size based on count
-        val baseSize = when {
-            count < 10 -> 40
-            count < 100 -> 48
-            count < 1000 -> 56
-            else -> 64
-        }
-        val size = (baseSize * density).roundToInt()
-
-        val bitmap = Bitmap.createBitmap(size, size, Bitmap.Config.ARGB_8888)
-        val canvas = Canvas(bitmap)
-
-        // Draw background circle
-        val bgPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-            color = backgroundColor
-            style = Paint.Style.FILL
-        }
-        canvas.drawCircle(size / 2f, size / 2f, size / 2f - borderWidth * density, bgPaint)
-
-        // Draw border
-        if (borderWidth > 0) {
-            val borderPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-                color = borderColor
-                style = Paint.Style.STROKE
-                strokeWidth = borderWidth * density
-            }
-            canvas.drawCircle(
-                size / 2f,
-                size / 2f,
-                size / 2f - borderWidth * density / 2,
-                borderPaint
-            )
-        }
-
-        // Draw count text
-        val text = formatCount(count)
-        val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
-            color = textColor
-            textSize = when {
-                count < 10 -> 16 * density
-                count < 100 -> 14 * density
-                count < 1000 -> 12 * density
-                else -> 10 * density
-            }
-            typeface = Typeface.DEFAULT_BOLD
-            textAlign = Paint.Align.CENTER
-        }
-
-        val textBounds = Rect()
-        textPaint.getTextBounds(text, 0, text.length, textBounds)
-        val textY = size / 2f + textBounds.height() / 2f
-        canvas.drawText(text, size / 2f, textY, textPaint)
-
-        val descriptor = BitmapDescriptorFactory.fromBitmap(bitmap)
-        iconCache[count] = descriptor
-        return descriptor
-    }
-
-    private fun formatCount(count: Int): String {
-        return when {
-            count >= 1000000 -> "${count / 1000000}M"
-            count >= 1000 -> "${count / 1000}K"
-            else -> count.toString()
-        }
-    }
-
-    fun clearCache() {
-        iconCache.clear()
-    }
-}

package/android/src/main/java/com/margelo/nitro/nitromap/ColorUtils.kt

@@ -1,63 +0,0 @@
-package com.margelo.nitro.nitromap
-
-import android.graphics.Color
-import androidx.core.graphics.toColorInt
-
-/**
- * Utility functions for converting color types to Android color integers
- */
-object ColorUtils {
-
-    /**
-     * Convert MarkerColor (RGBA) to Android color int
-     */
-    fun fromMarkerColor(color: MarkerColor): Int {
-        // Handle alpha: if <= 1.0, treat as 0-1 range and scale to 0-255
-        val alpha = if (color.a <= 1.0) (color.a * 255).toInt() else color.a.toInt()
-        return Color.argb(
-            alpha.coerceIn(0, 255),
-            color.r.toInt().coerceIn(0, 255),
-            color.g.toInt().coerceIn(0, 255),
-            color.b.toInt().coerceIn(0, 255)
-        )
-    }
-
-    /**
-     * Convert ColorValue (String | MarkerColor variant) to Android color int
-     */
-    fun fromColorValue(colorValue: ColorValue): Int {
-        return colorValue.match(
-            first = { hexString -> parseHexColor(hexString) },
-            second = { markerColor -> fromMarkerColor(markerColor) }
-        )
-    }
-
-    /**
-     * Convert Variant_String_MarkerColor to Android color int
-     */
-    fun fromVariant(variant: Variant_String_MarkerColor): Int {
-        return variant.match(
-            first = { hexString -> parseHexColor(hexString) },
-            second = { markerColor -> fromMarkerColor(markerColor) }
-        )
-    }
-
-    /**
-     * Parse hex color string to Android color int
-     * Supports formats: #RGB, #RRGGBB, #AARRGGBB, and color names
-     */
-    private fun parseHexColor(hexString: String): Int {
-        return try {
-            hexString.toColorInt()
-        } catch (e: Exception) {
-            Color.BLACK // Default fallback
-        }
-    }
-
-    /**
-     * Create a default ColorValue from a MarkerColor
-     */
-    fun defaultColorValue(r: Double, g: Double, b: Double, a: Double = 255.0): ColorValue {
-        return ColorValue.create(MarkerColor(r, g, b, a))
-    }
-}