@mappedin/react-native-sdk 6.0.0-alpha.0 → 6.0.0-alpha.11

package/lib/components/path.d.ts

@@ -0,0 +1,42 @@
+import type { Coordinate, TAddPathOptions } from '@mappedin/mappedin-js';
+import type { Mappedin } from '../types';
+export interface PathProps {
+    /**
+     * Array of coordinates to form the path
+     */
+    coordinate: Coordinate[];
+    /**
+     * Optional path options
+     */
+    options?: TAddPathOptions;
+    /**
+     * Callback called when path is successfully created
+     * @param path - The path object
+     */
+    onLoad?: (path: Mappedin.Path) => void;
+    /**
+     * Callback called when path animation completes
+     */
+    onDrawComplete?: () => void;
+}
+/**
+ * Path component for React Native.
+ *
+ * Displays a path on the map using the provided coordinates.
+ * The path is managed through the WebView bridge and communicates with the core SDK.
+ *
+ * @example
+ * ```tsx
+ * const directions = await mapView.getDirections(startSpace, endSpace);
+ * return directions ? (
+ *   <Path
+ *     coordinate={directions.coordinates}
+ *     options={{ color: 'blue', nearRadius: 0.5, farRadius: 0.5 }}
+ *     onLoad={(path) => console.log('Path loaded:', path)}
+ *     onDrawComplete={() => console.log('Path drawing complete')}
+ *   />
+ * ) : null;
+ * ```
+ */
+export declare function Path(props: PathProps): null;
+//# sourceMappingURL=path.d.ts.map

package/lib/components/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/components/path.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,UAAU,EAAE,UAAU,EAAE,CAAC;IACzB;;OAEG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC;IACvC;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,SAAS,QAmEpC"}

package/lib/components/shape.d.ts

@@ -0,0 +1,54 @@
+import type { Mappedin } from '../types';
+type Add = Mappedin.MapView['Shapes']['add'];
+export interface ShapeProps {
+    /**
+     * GeoJSON FeatureCollection containing the geometry for the shape
+     */
+    geometry: Parameters<Add>[0];
+    /**
+     * Style configuration for the shape
+     */
+    style: Parameters<Add>[1];
+    /**
+     * Optional floor to add the shape to
+     */
+    floor?: Parameters<Add>[2];
+    /**
+     * Callback called when shape is successfully created
+     * @param shape - The shape object
+     */
+    onLoad?: (shape: Mappedin.Shape) => void;
+}
+/**
+ * Shape component for React Native.
+ *
+ * Displays custom GeoJSON geometry on the map using the provided style.
+ * The shape is managed through the WebView bridge and communicates with the core SDK.
+ *
+ * @example
+ * ```tsx
+ * const geometry = {
+ *   type: 'FeatureCollection',
+ *   features: [{
+ *     type: 'Feature',
+ *     geometry: {
+ *       type: 'Polygon',
+ *       coordinates: [[[-80.521, 43.466], [-80.521, 43.465], [-80.520, 43.465], [-80.520, 43.466], [-80.521, 43.466]]]
+ *     },
+ *     properties: { id: 'my-shape' }
+ *   }]
+ * };
+ *
+ * return (
+ *   <Shape
+ *     geometry={geometry}
+ *     style={{ color: 'blue', height: 2, opacity: 0.7 }}
+ *     floor={currentFloor}
+ *     onLoad={(shape) => console.log('Shape loaded:', shape)}
+ *   />
+ * );
+ * ```
+ */
+export declare function Shape(props: ShapeProps): null;
+export {};
+//# sourceMappingURL=shape.d.ts.map

package/lib/components/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../../src/components/shape.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,KAAK,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7C,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,QAAQ,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7B;;OAEG;IACH,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,QAkEtC"}

package/lib/controls/event-control.d.ts

@@ -0,0 +1,89 @@
+import type { TEvents } from '@mappedin/mappedin-js';
+/**
+ * # Event Management System
+ *
+ * The React Native SDK uses a sophisticated event management system that bridges events
+ * between the WebView (where the actual map runs) and the React Native application.
+ *
+ * ## Architecture Overview
+ *
+ * The event system follows a hub-and-spoke pattern with these key principles:
+ *
+ * ### 1. Single WebView Subscription Per Event Type
+ * - The WebView only maintains **one subscription** per event type (e.g., 'click', 'hover')
+ * - This prevents duplicate event listeners and reduces overhead in the WebView
+ * - Event subscription is managed via the bridge communication layer
+ *
+ * ### 2. Multiple React Native Callbacks Per Event
+ * - Multiple React Native components can register callbacks for the same event type
+ * - When the WebView event fires, React Native receives it via the bridge
+ * - React Native then fires **all registered callbacks** for that event type
+ *
+ * ## Event Flow
+ *
+ * ```
+ * ┌─────────────────┐    ┌──────────────────┐    ┌─────────────────────┐
+ * │   React Native  │    │     Bridge       │    │      WebView        │
+ * │   Components    │    │   Communication  │    │   (Mappedin SDK)    │
+ * └─────────────────┘    └──────────────────┘    └─────────────────────┘
+ *          │                       │                        │
+ *          │ useEvent('click', cb1)│                        │
+ *          ├──────────────────────>│                        │
+ *          │                       │                        │
+ *          │                       │ Subscribe to 'click'   │
+ *          │                       ├─────────────────────-─>│
+ *          │                       │                        │
+ *          │                       │                        │ (Only once per
+ *          │ useEvent('click', cb2)│                        │  event type)
+ *          ├──────────────────────>│                        │
+ *          │                       │                        │
+ *          │                       │ (No new subscription)  │
+ *          │                       │    Click Event Fired   │
+ *          │                       │<────────────────────-──┤
+ *          │ cb1(eventData)        │                        │
+ *          │<──────────────────────┤                        │
+ *          │ cb2(eventData)        │                        │
+ *          │<──────────────────────┤                        │
+ * ```
+ * @internal This module is used internally by the SDK
+ */
+type TEventPayload<EventName extends keyof TEvents> = TEvents[EventName] extends {
+    data: null;
+} ? TEvents[EventName]['data'] : TEvents[EventName];
+type EventCallback<T extends keyof TEvents> = (payload: TEventPayload<T>) => void;
+/**
+ * Creates an event control system for managing event callbacks.
+ * This is used internally to manage event subscriptions and callbacks.
+ *
+ * @internal
+ */
+export declare function createEventControl(): {
+    /**
+     * Register a callback for a specific event type
+     * @internal
+     */
+    registerEventCallback<T extends keyof TEvents>(event: T, callback: EventCallback<T>): void;
+    /**
+     * Unregister a callback for a specific event type
+     * @internal
+     */
+    unregisterEventCallback<T extends keyof TEvents>(event: T, callback: EventCallback<T>): void;
+    /**
+     * Check if there are any callbacks registered for a specific event type
+     * @internal
+     */
+    hasEventCallbacks<T extends keyof TEvents>(event: T): boolean;
+    /**
+     * Trigger all callbacks for a specific event with the given payload
+     * @internal
+     */
+    handleEvent<T extends keyof TEvents>(event: T, payload: TEventPayload<T>): void;
+    /**
+     * Destroy all event callbacks
+     * @internal
+     */
+    destroy(): void;
+};
+export type EventControl = ReturnType<typeof createEventControl>;
+export {};
+//# sourceMappingURL=event-control.d.ts.map

package/lib/controls/event-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-control.d.ts","sourceRoot":"","sources":["../../src/controls/event-control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAEH,KAAK,aAAa,CAAC,SAAS,SAAS,MAAM,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,SAAS;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GAC5F,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GAC1B,OAAO,CAAC,SAAS,CAAC,CAAC;AAEtB,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAElF;;;;;GAKG;AACH,wBAAgB,kBAAkB;IAKhC;;;OAGG;0BACmB,CAAC,SAAS,MAAM,OAAO,SAAS,CAAC,YAAY,aAAa,CAAC,CAAC,CAAC;IAYnF;;;OAGG;4BACqB,CAAC,SAAS,MAAM,OAAO,SAAS,CAAC,YAAY,aAAa,CAAC,CAAC,CAAC;IAYrF;;;OAGG;sBACe,CAAC,SAAS,MAAM,OAAO,SAAS,CAAC,GAAG,OAAO;IAO7D;;;OAGG;gBACS,CAAC,SAAS,MAAM,OAAO,SAAS,CAAC,WAAW,aAAa,CAAC,CAAC,CAAC;IAgBxE;;;OAGG;;EAKJ;AAED,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/lib/controls/map-view-control.d.ts

@@ -0,0 +1,210 @@
+import type { MapView, Space, TUpdateState, TUpdateStates, Text3D, MapObject, Label, Marker, Shape, Door, Facade, Floor, WALLS, DOORS, Model, Path, PathSegment, Directions, TNavigationOptions, TAddMarkerOptions, TStateChangedInternalPayload } from '@mappedin/mappedin-js';
+import type { UseBridgeHook } from '../hooks/use-bridge.js';
+import type { Mappedin } from '../types.js';
+import type { EventControl } from './event-control.js';
+/**
+ * Configuration for a navigation marker's template and display options.
+ *
+ * @example
+ * ```typescript
+ * // Basic distance marker
+ * {
+ *   template: 'Distance: {{instruction.distance}}m',
+ *   options: { interactive: true, rank: 'high' }
+ * }
+ *
+ * // Turn instruction marker
+ * {
+ *   template: 'Turn {{instruction.action.bearing}} in {{instruction.distance}}m',
+ *   options: { rank: 'medium' }
+ * }
+ * ```
+ */
+export type NavigationMarkerConfig = {
+    /**
+     * Handlebars templates receive objects with an 'instruction' property containing TDirectionInstruction data. @see {@link TDirectionInstruction} in @mappedin/mappedin-js for full type details
+     *
+     * @example
+     * ```typescript
+     * {
+     *   template: '<div>Turn {{instruction.action.bearing}} in {{instruction.distance}}m</div>',
+     * }
+     */
+    template?: string;
+    /** Optional configuration for marker behavior */
+    options?: TAddMarkerOptions;
+};
+/**
+ * Extended navigation options that support configurable markers.
+ *
+ * Example:
+ * ```typescript
+ * createMarkers: {
+ *   departure: {
+ *     template: 'Departure: {{instruction.action.type}}',
+ *     options: { interactive: true }
+ *   },
+ *   destination: {
+ *     template: 'Destination: {{instruction.action.type}}',
+ *     options: { rank: 'medium' }
+ *   },
+ *   connection: false // Disable connection markers
+ * }
+ * ```
+ */
+export type ExtendedNavigationOptions = Omit<TNavigationOptions, 'createMarkers'> & {
+    createMarkers?: {
+        /** Departure marker configuration or boolean to enable/disable */
+        departure?: NavigationMarkerConfig | boolean;
+        /** Destination marker configuration or boolean to enable/disable */
+        destination?: NavigationMarkerConfig | boolean;
+        /** Connection marker configuration or boolean to enable/disable */
+        connection?: NavigationMarkerConfig | boolean;
+    };
+};
+type Promisify<T> = {
+    [K in keyof T]: T[K] extends (...args: infer Args) => infer Return ? Return extends Promise<any> ? T[K] : (...args: Args) => Promise<Return> : T[K] extends object ? Promisify<T[K]> : T[K];
+};
+type PromisifiedUpdateState = {
+    <T extends Space | Text3D | MapObject | Label | Marker | Shape | Door | Facade | Floor | WALLS | DOORS | Model | Path | PathSegment>(target: T, state: TUpdateState<T>): Promise<void>;
+    <T extends string & NonNullable<unknown>>(target: T, state: TUpdateStates): Promise<void>;
+};
+/**
+ * Extended navigation with custom marker templates
+ *
+ * @see {@link ExtendedNavigationOptions} for more information on the options
+ *
+ * @interface
+ */
+export type Navigation = {
+    draw(directions: Directions | Directions[], options?: ExtendedNavigationOptions): Promise<void>;
+} & Omit<MapView['Navigation'], 'draw'>;
+type MapViewMethods = Omit<MapView, 'on' | 'off' | 'emit' | '__core' | 'then' | 'catch' | 'finally' | 'valueOf' | 'toString' | 'toJSON' | typeof Symbol.toPrimitive | typeof Symbol.toStringTag> & {
+    /**
+     * Internal method used by useEvent hook to call the bridge.
+     *
+     * @remarks
+     * This method is used by useEvent hook to call the bridge.
+     * It is not part of the public API and should not be used directly.
+     *
+     * @internal
+     */
+    _bridgeCall: UseBridgeHook['instruct'];
+};
+/**
+ * A proxy that intercepts {@link MapView} method calls and forwards them through the bridge to the WebView.
+ * All method calls are converted to asynchronous bridge instructions.
+ *
+ * This interface provides access to all MapView methods and properties in an async manner,
+ * with specialized handling for Navigation and updateState methods.
+ *
+ * **Key Properties:**
+ * - `updateState` - Async wrapper for updating entity states with type safety
+ * - `Navigation` - Extended navigation with custom marker templates
+ * - `on` - Subscribe to map events
+ * - `off` - Unsubscribe from map events
+ * - `destroy` - Clean up resources and event subscriptions
+ * - All other MapView methods are available as async calls
+ *
+ * @example Basic Usage
+ * ```typescript
+ * // All MapView methods are available as async calls
+ * await mapView.setFloor('floor-id');
+ * await mapView.Camera.focusOn(target, options);
+ * await mapView.Labels.add(coordinate, content);
+ *
+ * // Navigation with custom markers
+ * await mapView.Navigation.draw(directions, {
+ *   createMarkers: {
+ *     connection: { template: '<div>{{instruction.action.type}}</div>', options: { rank: 'always-visible' } }
+ *   }
+ * });
+ *
+ * // Event handling
+ * mapView.on('click', handler);
+ * mapView.off('click', handler);
+ *
+ * // Cleanup when unmounting
+ * mapView.destroy();
+ * ```
+ *
+ * @interface
+ */
+export type MapViewControl = Omit<Promisify<MapViewMethods>, 'updateState' | 'Navigation'> & {
+    /** Async wrapper for updating entity states with type safety */
+    updateState: PromisifiedUpdateState;
+    /** Extended navigation with custom marker templates */
+    Navigation: Navigation;
+    /** Subscribe to map events */
+    on: MapView['on'];
+    /** Unsubscribe from map events */
+    off: MapView['off'];
+    /** Destroy resources, caches, and event subscriptions */
+    destroy: () => Promise<void>;
+    /**
+     * Internal method to get cache state for testing
+     * @internal
+     */
+    __getCacheState?: () => {
+        cacheSize: number;
+        propertyCacheKeys: string[];
+    };
+};
+/**
+ * Creates a typed wrapper that allows calling any method on the MapView class through the bridge.
+ *
+ * Features:
+ * - Full TypeScript support with auto-completion
+ * - Type-safe method calls with proper parameter and return type checking
+ * - Supports any method call on MapView (e.g., mapView.setFloor(...))
+ * - Supports namespaced methods (e.g., mapView.Camera.focusOn(...))
+ * - Supports property access for direct values (e.g., mapView.currentFloor, mapView.Camera.maxZoomLevel)
+ * - All methods automatically return Promises since they go through the bridge
+ * - Properties return cached values directly (synchronously)
+ * - Automatically stays in sync with MapView API changes
+ * - Subscribes to camera-state-change events to keep camera properties in sync
+ * - Extended Navigation.draw method supports custom createMarker property
+ *
+ * Usage examples:
+ * ```typescript
+ * const mapView = createMapViewControl(instruct);
+ *
+ * // Direct method calls with full type safety
+ * await mapView.setFloor('floor-id'); // TypeScript knows the parameter type
+ *
+ * // Namespaced method calls with auto-completion
+ * await mapView.Camera.focusOn(target, options);
+ * await mapView.Labels.add(coordinate, content);
+ * await mapView.Markers.add(coordinate, '<div>Marker</div>');
+ *
+ * // Extended Navigation.draw with custom createMarker property
+ * await mapView.Navigation.draw(directions, {
+ *   createMarkers: {
+ *     departure: '<div>departure</div>',
+ *     destination: false,
+ *     connection: '<div>connection {{instruction.action.type}}</div>',
+ *   },
+ *   pathOptions: { color: '#ff0000' },
+ *   // ... all other TNavigationOptions remain available
+ * });
+ *
+ * // Property access returns cached values directly (no await needed)
+ * const currentFloor = mapView.currentFloor; // Returns 'floor-1'
+ * const maxZoom = mapView.Camera.maxZoomLevel; // Returns 1
+ * const minZoom = mapView.Camera.minZoomLevel; // Returns 0.5
+ *
+ * // All method return types are properly typed as Promises
+ * const directions = await mapView.getDirections(from, to);
+ * const mapData = await mapView.getMapData();
+ * ```
+ *
+ * @param instruct - The bridge instruction function from useBridge hook
+ * @param mapData - The map data for the map view
+ * @param eventControl - Optional event control instance for handling events
+ * @returns A typed proxy that intercepts any method call and forwards it to the bridge
+ */
+export declare function createMapViewControl(instruct: UseBridgeHook['instruct'], mapData: Mappedin.MapData, eventControl: EventControl, { startInitialState }?: {
+    startInitialState?: TStateChangedInternalPayload;
+}): Promise<MapViewControl>;
+export {};
+//# sourceMappingURL=map-view-control.d.ts.map

package/lib/controls/map-view-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-view-control.d.ts","sourceRoot":"","sources":["../../src/controls/map-view-control.ts"],"names":[],"mappings":"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"}

package/lib/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class MapViewNullError extends Error {
+    constructor(name: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,gBAAiB,SAAQ,KAAK;gBAC9B,IAAI,EAAE,MAAM;CAGxB"}

package/lib/hooks/use-bridge.d.ts

@@ -0,0 +1,73 @@
+import type { WebView, WebViewMessageEvent } from 'react-native-webview';
+/**
+ * React hook for communicating with a WebView using a bridge pattern.
+ *
+ * @example
+ * ```tsx
+ * import { useRef, useState } from 'react';
+ * import { WebView } from 'react-native-webview';
+ * import { useBridge } from './hooks/use-bridge';
+ *
+ * function MyComponent() {
+ *   const [webView, setWebView] = useState<WebView | null>(null);
+ *   const { instruct, handleMessage, cleanup } = useBridge(webView);
+ *
+ *   const handlePress = async () => {
+ *     try {
+ *       const result = await instruct({
+ *         type: 'function',
+ *         payload: {
+ *           name: 'getMapData',
+ *           options: [{ venueId: '123' }]
+ *         }
+ *       });
+ *       console.log('Map data:', result);
+ *     } catch (error) {
+ *       console.error('Failed to get map data:', error);
+ *     }
+ *   };
+ *
+ *   // Clean up on unmount
+ *   useEffect(() => {
+ *     return () => {
+ *       cleanup();
+ *     };
+ *   }, [cleanup]);
+ *
+ *   return (
+ *     <WebView
+ *       ref={setWebView}
+ *       source={{ uri: 'https://example.com' }}
+ *       onMessage={handleMessage}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @param webView - The WebView instance (can be null)
+ * @returns Object containing the instruct function, handleMessage callback, and cleanup function
+ */
+type FunctionInstruction = {
+    type: 'function';
+    payload: {
+        name: string;
+        options?: any[];
+    };
+};
+type MethodInstruction = {
+    type: 'method';
+    payload: {
+        target: string;
+        method: string;
+        args?: any[];
+    };
+};
+export type Instruction = FunctionInstruction | MethodInstruction;
+export declare function useBridge(webView: WebView | null): {
+    instruct: <T = any>(instruction: Instruction) => Promise<T>;
+    handleMessage: (event: WebViewMessageEvent) => void;
+    destroy: () => void;
+};
+export type UseBridgeHook = ReturnType<typeof useBridge>;
+export {};
+//# sourceMappingURL=use-bridge.d.ts.map

package/lib/hooks/use-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-bridge.d.ts","sourceRoot":"","sources":["../../src/hooks/use-bridge.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,KAAK,mBAAmB,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE;QACR,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;KAChB,CAAC;CACF,CAAC;AACF,KAAK,iBAAiB,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE;QACR,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;KACb,CAAC;CACF,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,mBAAmB,GAAG,iBAAiB,CAAC;AAqBlE,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;eA+B9C,CAAC,qBAAqB,WAAW,KAAG,OAAO,CAAC,CAAC,CAAC;2BA3BN,mBAAmB;;EAsF7D;AAED,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC"}

package/lib/hooks/use-event.d.ts

@@ -0,0 +1,27 @@
+import type { TEvents } from '@mappedin/mappedin-js';
+type TEventPayload<EventName extends keyof TEvents> = TEvents[EventName] extends {
+    data: null;
+} ? TEvents[EventName]['data'] : TEvents[EventName];
+/**
+ * Hook to subscribe to an event on the MapView in React Native.
+ *
+ * This hook uses the MapView's .on() and .off() methods to subscribe to events
+ * on the MapView instance running in the WebView.
+ *
+ * @param event - The event to listen for.
+ * @param callback - The callback to call when the event is triggered.
+ *
+ * @category Hooks
+ *
+ * @example
+ * ```tsx
+ * useEvent('click', event => {
+ *  const { coordinate } = event;
+ *  const { latitude, longitude } = coordinate;
+ *  console.log(`Map was clicked at ${latitude}, ${longitude}`);
+ * });
+ * ```
+ */
+export declare function useEvent<T extends keyof TEvents>(event: T, callback: (payload: TEventPayload<T>) => void): void;
+export {};
+//# sourceMappingURL=use-event.d.ts.map

package/lib/hooks/use-event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-event.d.ts","sourceRoot":"","sources":["../../src/hooks/use-event.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAErD,KAAK,aAAa,CAAC,SAAS,SAAS,MAAM,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,SAAS;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,GAC5F,OAAO,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GAC1B,OAAO,CAAC,SAAS,CAAC,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,KAAK,IAAI,QAwCxG"}

package/lib/hooks/use-map.d.ts

@@ -0,0 +1,42 @@
+import type { Mappedin } from '../types';
+import type { MapViewControl } from '../controls/map-view-control';
+import type { EventControl } from '../controls/event-control';
+export declare const MappedinContext: import("react").Context<{
+    mapData?: Mappedin.MapData;
+    mapView?: MapViewControl;
+    /**
+     * Event control system for managing event callbacks.
+     * @internal
+     */
+    _events?: EventControl;
+}>;
+/**
+ * Hook to get the MapData and MapView instances from the MapView context.
+ *
+ * This hook provides access to the mapData and mapView instances that are
+ * created and managed by the MapView component. It ensures that the hook
+ * is used within a MapView component context.
+ *
+ * @throws {MapViewNullError} When used outside of a MapView component or when mapData/mapView are not yet initialized
+ *
+ * @returns Object containing mapData and mapView instances
+ *
+ * @example
+ * ```tsx
+ * function MyMapComponent() {
+ *   const { mapData, mapView } = useMap();
+ *
+ *   useEffect(() => {
+ *     // Use mapView to interact with the map
+ *     mapView.Camera.animateTo({ center: mapData.getByType('space')[0] });
+ *   }, [mapData, mapView]);
+ *
+ *   return <Text>Map is ready!</Text>;
+ * }
+ * ```
+ */
+export declare function useMap(): {
+    mapData: Mappedin.MapData;
+    mapView: MapViewControl;
+};
+//# sourceMappingURL=use-map.d.ts.map

package/lib/hooks/use-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-map.d.ts","sourceRoot":"","sources":["../../src/hooks/use-map.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAG9D,eAAO,MAAM,eAAe;cACjB,QAAQ,CAAC,OAAO;cAChB,cAAc;IACxB;;;OAGG;cACO,YAAY;EAKrB,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,MAAM,IAAI;IACzB,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC;IAC1B,OAAO,EAAE,cAAc,CAAC;CACxB,CAQA"}

package/lib/index.d.ts

@@ -0,0 +1,19 @@
+export { MapView } from './map-view';
+export type { MapViewProps } from './map-view';
+export { useMap, MappedinContext } from './hooks/use-map';
+export { type MapViewControl } from './controls/map-view-control';
+export { useEvent } from './hooks/use-event';
+export { Marker } from './components/marker';
+export type { MarkerProps } from './components/marker';
+export { Label } from './components/label';
+export type { LabelProps } from './components/label';
+export { Path } from './components/path';
+export type { PathProps } from './components/path';
+export { Shape } from './components/shape';
+export type { ShapeProps } from './components/shape';
+export type { Navigation } from './controls/map-view-control';
+export { Model } from './components/model';
+export type { ModelProps } from './components/model';
+export { setLoggerLevel } from './utils';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACrC,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AACzC,YAAY,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,YAAY,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,YAAY,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,cAAc,SAAS,CAAC"}