@mapfirst.ai/react 0.0.43 → 0.0.45

package/dist/index.d.mts

@@ -226,15 +226,15 @@ type SmartFilter = {
  * }, [mapLibreInstance]);
  *
  * // Use search methods
- * await propertiesSearch.search({
+ * await propertiesSearch({
  *   body: { city: "Paris", country: "France" }
  * });
  *
- * await smartFilterSearch.search({
+ * await smartFilterSearch({
  *   query: "hotels near beach with pool"
  * });
  *
- * await boundsSearch.perform();
+ * await boundsSearch();
  * ```
  */
 declare function useMapFirst(options: BaseMapFirstOptions): {
@@ -243,54 +243,48 @@ declare function useMapFirst(options: BaseMapFirstOptions): {
     setPrimaryType: (type: PropertyType) => void;
     setSelectedMarker: (id: number | null) => void;
     setUseApi: (useApi: boolean, autoLoad?: boolean) => void;
-    propertiesSearch: {
-        search: (options: {
-            body: InitialRequestBody;
-            beforeApplyProperties?: (data: any) => {
-                price?: any;
-                limit?: number;
-            };
-            smartFiltersClearable?: boolean;
-            onError?: (error: unknown) => void;
-        }) => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
-    smartFilterSearch: {
-        search: (options: {
-            query?: string;
-            filters?: SmartFilter[];
-            onProcessFilters?: (filters: any, location_id?: number) => {
-                smartFilters?: SmartFilter[];
-                price?: any;
-                limit?: number;
-                language?: string;
-            };
-            onError?: (error: unknown) => void;
-        }) => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
-    boundsSearch: {
-        perform: () => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
+    propertiesSearch: (options: {
+        body: InitialRequestBody;
+        beforeApplyProperties?: (data: any) => {
+            price?: any;
+            limit?: number;
+        };
+        smartFiltersClearable?: boolean;
+        onError?: (error: unknown) => void;
+    }) => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
+    smartFilterSearch: (options: {
+        query?: string;
+        filters?: SmartFilter[];
+        onProcessFilters?: (filters: any, location_id?: number) => {
+            smartFilters?: SmartFilter[];
+            price?: any;
+            limit?: number;
+            language?: string;
+        };
+        onError?: (error: unknown) => void;
+    }) => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
+    boundsSearch: () => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
     attachMapLibre: (map: any, maplibregl: MapLibreNamespace, options?: {
         onMarkerClick?: (marker: Property) => void;
     }) => void;

package/dist/index.d.ts

@@ -226,15 +226,15 @@ type SmartFilter = {
  * }, [mapLibreInstance]);
  *
  * // Use search methods
- * await propertiesSearch.search({
+ * await propertiesSearch({
  *   body: { city: "Paris", country: "France" }
  * });
  *
- * await smartFilterSearch.search({
+ * await smartFilterSearch({
  *   query: "hotels near beach with pool"
  * });
  *
- * await boundsSearch.perform();
+ * await boundsSearch();
  * ```
  */
 declare function useMapFirst(options: BaseMapFirstOptions): {
@@ -243,54 +243,48 @@ declare function useMapFirst(options: BaseMapFirstOptions): {
     setPrimaryType: (type: PropertyType) => void;
     setSelectedMarker: (id: number | null) => void;
     setUseApi: (useApi: boolean, autoLoad?: boolean) => void;
-    propertiesSearch: {
-        search: (options: {
-            body: InitialRequestBody;
-            beforeApplyProperties?: (data: any) => {
-                price?: any;
-                limit?: number;
-            };
-            smartFiltersClearable?: boolean;
-            onError?: (error: unknown) => void;
-        }) => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
-    smartFilterSearch: {
-        search: (options: {
-            query?: string;
-            filters?: SmartFilter[];
-            onProcessFilters?: (filters: any, location_id?: number) => {
-                smartFilters?: SmartFilter[];
-                price?: any;
-                limit?: number;
-                language?: string;
-            };
-            onError?: (error: unknown) => void;
-        }) => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
-    boundsSearch: {
-        perform: () => Promise<{
-            location_id?: number;
-            filters: _mapfirst_ai_core.FilterSchema;
-            properties: Property[];
-            isComplete: boolean | undefined;
-            pollingLink: string | undefined;
-            durationSeconds: number;
-        } | null>;
-    };
+    propertiesSearch: (options: {
+        body: InitialRequestBody;
+        beforeApplyProperties?: (data: any) => {
+            price?: any;
+            limit?: number;
+        };
+        smartFiltersClearable?: boolean;
+        onError?: (error: unknown) => void;
+    }) => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
+    smartFilterSearch: (options: {
+        query?: string;
+        filters?: SmartFilter[];
+        onProcessFilters?: (filters: any, location_id?: number) => {
+            smartFilters?: SmartFilter[];
+            price?: any;
+            limit?: number;
+            language?: string;
+        };
+        onError?: (error: unknown) => void;
+    }) => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
+    boundsSearch: () => Promise<{
+        location_id?: number;
+        filters: _mapfirst_ai_core.FilterSchema;
+        properties: Property[];
+        isComplete: boolean | undefined;
+        pollingLink: string | undefined;
+        durationSeconds: number;
+    } | null>;
     attachMapLibre: (map: any, maplibregl: MapLibreNamespace, options?: {
         onMarkerClick?: (marker: Property) => void;
     }) => void;

package/dist/index.js

@@ -1450,6 +1450,14 @@ function useMapFirst(options) {
         onSearchingStateChange: (searching) => {
           updateStateField(setState, "isSearching", searching);
           forwardCallback(optionsRef, "onSearchingStateChange", searching);
+        },
+        onFirstCallDoneChange: (firstCallDone) => {
+          updateStateField(setState, "firstCallDone", firstCallDone);
+          forwardCallback(optionsRef, "onFirstCallDoneChange", firstCallDone);
+        },
+        onIsFlyToAnimatingChange: (animating) => {
+          updateStateField(setState, "isFlyToAnimating", animating);
+          forwardCallback(optionsRef, "onIsFlyToAnimatingChange", animating);
         }
       }
     };
@@ -1480,39 +1488,30 @@ function useMapFirst(options) {
     },
     []
   );
-  const propertiesSearch = import_react9.default.useMemo(
-    () => ({
-      search: async (options2) => {
-        if (!instanceRef.current) {
-          throw new Error("MapFirst instance not available");
-        }
-        return await instanceRef.current.runPropertiesSearch(options2);
-      }
-    }),
-    []
-  );
-  const smartFilterSearch = import_react9.default.useMemo(
-    () => ({
-      search: async (options2) => {
-        if (!instanceRef.current) {
-          throw new Error("MapFirst instance not available");
-        }
-        return await instanceRef.current.runSmartFilterSearch(options2);
+  const propertiesSearch = import_react9.default.useCallback(
+    async (options2) => {
+      if (!instanceRef.current) {
+        throw new Error("MapFirst instance not available");
       }
-    }),
+      return await instanceRef.current.runPropertiesSearch(options2);
+    },
     []
   );
-  const boundsSearch = import_react9.default.useMemo(
-    () => ({
-      perform: async () => {
-        if (!instanceRef.current) {
-          return null;
-        }
-        return await instanceRef.current.performBoundsSearch();
+  const smartFilterSearch = import_react9.default.useCallback(
+    async (options2) => {
+      if (!instanceRef.current) {
+        throw new Error("MapFirst instance not available");
       }
-    }),
+      return await instanceRef.current.runSmartFilterSearch(options2);
+    },
     []
   );
+  const boundsSearch = import_react9.default.useCallback(async () => {
+    if (!instanceRef.current) {
+      return null;
+    }
+    return await instanceRef.current.performBoundsSearch();
+  }, []);
   const mapLibreAttachedRef = import_react9.default.useRef(false);
   const attachMapLibre = import_react9.default.useCallback(
     (map, maplibregl, options2) => {

package/dist/index.mjs

@@ -1410,6 +1410,14 @@ function useMapFirst(options) {
         onSearchingStateChange: (searching) => {
           updateStateField(setState, "isSearching", searching);
           forwardCallback(optionsRef, "onSearchingStateChange", searching);
+        },
+        onFirstCallDoneChange: (firstCallDone) => {
+          updateStateField(setState, "firstCallDone", firstCallDone);
+          forwardCallback(optionsRef, "onFirstCallDoneChange", firstCallDone);
+        },
+        onIsFlyToAnimatingChange: (animating) => {
+          updateStateField(setState, "isFlyToAnimating", animating);
+          forwardCallback(optionsRef, "onIsFlyToAnimatingChange", animating);
         }
       }
     };
@@ -1440,39 +1448,30 @@ function useMapFirst(options) {
     },
     []
   );
-  const propertiesSearch = React6.useMemo(
-    () => ({
-      search: async (options2) => {
-        if (!instanceRef.current) {
-          throw new Error("MapFirst instance not available");
-        }
-        return await instanceRef.current.runPropertiesSearch(options2);
-      }
-    }),
-    []
-  );
-  const smartFilterSearch = React6.useMemo(
-    () => ({
-      search: async (options2) => {
-        if (!instanceRef.current) {
-          throw new Error("MapFirst instance not available");
-        }
-        return await instanceRef.current.runSmartFilterSearch(options2);
+  const propertiesSearch = React6.useCallback(
+    async (options2) => {
+      if (!instanceRef.current) {
+        throw new Error("MapFirst instance not available");
       }
-    }),
+      return await instanceRef.current.runPropertiesSearch(options2);
+    },
     []
   );
-  const boundsSearch = React6.useMemo(
-    () => ({
-      perform: async () => {
-        if (!instanceRef.current) {
-          return null;
-        }
-        return await instanceRef.current.performBoundsSearch();
+  const smartFilterSearch = React6.useCallback(
+    async (options2) => {
+      if (!instanceRef.current) {
+        throw new Error("MapFirst instance not available");
       }
-    }),
+      return await instanceRef.current.runSmartFilterSearch(options2);
+    },
     []
   );
+  const boundsSearch = React6.useCallback(async () => {
+    if (!instanceRef.current) {
+      return null;
+    }
+    return await instanceRef.current.performBoundsSearch();
+  }, []);
   const mapLibreAttachedRef = React6.useRef(false);
   const attachMapLibre = React6.useCallback(
     (map, maplibregl, options2) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapfirst.ai/react",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "description": "React hooks for MapFirst SDK - Reactive state management for map properties",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,7 +40,7 @@
     "react": ">=17"
   },
   "dependencies": {
-    "@mapfirst.ai/core": "0.0.37"
+    "@mapfirst.ai/core": "0.0.38"
   },
   "scripts": {
     "build": "tsup src/index.tsx --format esm,cjs --dts --clean"