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

package/lib/components/model.d.ts

@@ -0,0 +1,45 @@
+import type { Coordinate, TAddModelOptions } from '@mappedin/mappedin-js';
+import type { Mappedin } from '../types';
+export interface ModelProps {
+    /**
+     * The target coordinate where the model should be placed
+     */
+    target: Coordinate;
+    /**
+     * URL of the 3D model (GLTF or GLB format)
+     */
+    url: string;
+    /**
+     * Optional model options
+     */
+    options?: TAddModelOptions;
+    /**
+     * Callback called when model is successfully created
+     * @param model - The model object
+     */
+    onLoad?: (model: Mappedin.Model) => void;
+}
+/**
+ * Model component for React Native.
+ *
+ * Displays a 3D model on the map at the specified coordinate.
+ * The model is managed through the WebView bridge and communicates with the core SDK.
+ * Models are in GLTF or GLB format and can be scaled, rotated, and positioned.
+ *
+ * @example
+ * ```tsx
+ * <Model
+ *   target={coordinate}
+ *   url="https://example.com/model.glb"
+ *   options={{
+ *     scale: [2, 2, 2],
+ *     rotation: [0, 90, 0],
+ *     opacity: 0.8,
+ *     interactive: true
+ *   }}
+ *   onLoad={(model) => console.log('Model loaded:', model)}
+ * />
+ * ```
+ */
+export declare function Model(props: ModelProps): null;
+//# sourceMappingURL=model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/components/model.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,WAAW,UAAU;IAC1B;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC;IACnB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,KAAK,IAAI,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,QA2DtC"}

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', width: 1 }}
+ *     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,360 @@
+import type { MapView, TUpdateState, Directions, TNavigationOptions, TAddMarkerOptions, TStateChangedInternalPayload, MapElementsWithState } 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;
+    };
+};
+/**
+ * Utility type that converts all methods in a given type to return Promises.
+ * Used in MapViewControl to wrap synchronous MapView methods for async bridge communication.
+ *
+ * @template T - The type to promisify
+ *
+ * @example
+ * ```typescript
+ * // Original synchronous API
+ * interface TextAPI {
+ *   label(space: Space): Text3D;
+ *   remove(text: Text3D): void;
+ * }
+ *
+ * // Promisified version
+ * type AsyncTextAPI = Promisify<TextAPI>;
+ * // Results in:
+ * // {
+ * //   label(space: Space): Promise<Text3D>;
+ * //   remove(text: Text3D): Promise<void>;
+ * // }
+ * ```
+ *
+ * @remarks
+ * TypeScript's type system has limitations with complex generic transformations.
+ * The basic Promisify works well for simple cases but struggles with:
+ * - Function overloads - only the last overload signature is preserved
+ * - Generic functions with conditional return types - type information is lost
+ * - Complex generic constraints - requires manual type definitions
+ */
+export 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 definition for the promisified updateState method with function overloads preserved.
+ *
+ * This type specifically handles the complex overloaded signatures of updateState that the generic
+ * Promisify utility cannot properly preserve. It maintains full type safety for both entity objects
+ * and string IDs while ensuring all calls return Promises for bridge communication.
+ *
+ * @template T - The entity type being updated (Space, Text3D, etc.) or string ID
+ *
+ * @example Type-safe entity updates
+ * ```typescript
+ * // Space update with full type safety
+ * const space: Space = mapData.getByType('space')[0];
+ * await mapView.updateState(space, {
+ *   color: '#ff0000',        // ✅ Valid Space property
+ *   opacity: 0.8,           // ✅ Valid Space property
+ *   invalidProp: 'value'    // ❌ TypeScript error - not a Space property
+ * });
+ *
+ * // Text3D update with specific styling options
+ * const text3D: Text3D = await mapView.Text3D.label(space, 'Room 101');
+ * await mapView.updateState(text3D, {
+ *   color: '#0066cc',       // ✅ Valid Text3D property
+ *   fontSize: 16,           // ✅ Valid Text3D property
+ *   fillOpacity: 0.9        // ✅ Valid Text3D property
+ * });
+ *
+ * // Marker update with positioning and visibility
+ * const marker: Marker = await mapView.Markers.add(coordinate, '<div>Pin</div>');
+ * await mapView.updateState(marker, {
+ *   rank: 'always-visible'       // ✅ Valid Marker property
+ * });
+ * ```
+ *
+ *
+ * @example Error handling and validation
+ * ```typescript
+ * try {
+ *   await mapView.updateState(space, { color: '#invalid-color' });
+ * } catch (error) {
+ *   console.error('State update failed:', error);
+ *   // Handle bridge communication errors
+ * }
+ * ```
+ *
+ * @remarks
+ * **Why this type exists:**
+ * - The generic `Promisify<T>` utility cannot preserve function overloads
+ * - TypeScript intersection types from overloads lose individual signature information
+ * - This explicit type maintains both overload signatures with proper type safety
+ * - Ensures consistent Promise return types for all bridge operations
+ *
+ */
+export type PromisifiedUpdateState = <T extends MapElementsWithState>(target: T, state: TUpdateState<T>) => 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' | 'Text3D' | 'BlueDot' | 'Camera' | 'Labels' | 'Markers' | 'Models' | 'Images' | 'Paths' | 'Shapes' | 'Style' | 'Outdoor'> & {
+    /**
+     * Promisified version of updateState that asynchronously updates visual properties of map entities.
+     *
+     * This method provides type-safe updates for various map entities with async bridge communication.
+     * All state changes are applied through the React Native bridge and return a Promise.
+     *
+     * @param target - The entity to update (Space, Text3D, Marker, Label, etc.) or its string ID
+     * @param state - The new state properties to apply to the entity
+     * @returns Promise that resolves when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // Update a space's appearance
+     * const space = mapData.getByType('space')[0];
+     * await mapView.updateState(space, {
+     *   color: '#ff0000',
+     *   opacity: 0.8
+     * });
+     *
+     * // Update a 3D text label
+     * const text3D = await mapView.Text3D.label(space, 'Room 101');
+     * await mapView.updateState(text3D, {
+     *   color: '#0066cc',
+     *   fontSize: 16,
+     *   fillOpacity: 0.9
+     * });
+     *
+     * // Update a marker's styling
+     * const marker = await mapView.Markers.add(coordinate, '<div>Custom Marker</div>');
+     * await mapView.updateState(marker, {
+     *   rank: 'always-visible'
+     * });
+     *
+     * // Update using string ID
+     * await mapView.updateState('space-id-123', {
+     *   color: '#00ff00',
+     *   opacity: 0.5
+     * });
+     *
+     * @remarks
+     * Unlike the synchronous MapView.updateState, this method:
+     * - Returns a Promise that resolves when the bridge operation completes
+     * - Provides full TypeScript type safety for all supported entity types
+     * - Handles bridge communication errors gracefully
+     * - Supports both entity objects and string IDs as targets
+     *
+     * Supported entity types include: Space, Text3D, MapObject, Label, Marker, Shape,
+     * Door, Facade, Floor, Model, Path, PathSegment, and string IDs.
+     */
+    updateState: PromisifiedUpdateState;
+    /** Extended navigation with custom marker templates */
+    Navigation: Navigation;
+    /** 3D text controls with async methods */
+    Text3D: Promisify<import('@mappedin/mappedin-js').Text3D>;
+    /** Blue dot controls with async methods */
+    BlueDot: Promisify<import('@mappedin/mappedin-js').MapView['__BlueDot']>;
+    /** Camera controls with async methods */
+    Camera: Promisify<import('@mappedin/mappedin-js').Camera>;
+    /** Label controls with async methods */
+    Labels: Promisify<import('@mappedin/mappedin-js').Labels>;
+    /** Marker controls with async methods */
+    Markers: Promisify<import('@mappedin/mappedin-js').Markers>;
+    /** Model controls with async methods */
+    Models: Promisify<import('@mappedin/mappedin-js').Models>;
+    /** Image controls with async methods */
+    Images: Promisify<import('@mappedin/mappedin-js').Images>;
+    /** Path controls with async methods */
+    Paths: Promisify<import('@mappedin/mappedin-js').Paths>;
+    /** Shape controls with async methods */
+    Shapes: Promisify<import('@mappedin/mappedin-js').Shapes>;
+    /** Style controls with async methods */
+    Style: Promisify<import('@mappedin/mappedin-js').Style>;
+    /** Outdoor controls with async methods */
+    Outdoor: Promisify<import('@mappedin/mappedin-js').Outdoor>;
+    /** 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"}