easy-google-places 1.0.0

package/README.md

@@ -0,0 +1,101 @@
+# Easy Google Restaurants
+
+A TypeScript library to query Google Places API with automatic area subdivision used to bypass the 60 results limit.
+
+## Features
+
+- **Automatic Subdivision**: Splits large search areas into smaller 500m radius sub-circles to maximize results, overcoming the 60-result limit per query.
+- **Fluent API**: Easy-to-use chainable methods for configuration.
+- **Rate Limiting**: Handles API pagination and rate limiting automatically.
+- **Filtering**: By default, filters out temporarily closed places (configurable).
+- **Flexible Output**: Export to JSON, CSV, or handle results with a custom callback.
+
+## Installation
+
+```bash
+npm install easy-google-places
+# or
+bun add easy-google-places
+# or
+yarn add easy-google-places
+```
+
+## Basic Usage
+
+```typescript
+import { getGooglePlaces } from "easy-google-places";
+
+// Coordinates for the center of your search (e.g., Paris)
+const location = { latitude: 48.8566, longitude: 2.3522 };
+
+await getGooglePlaces(location)
+  .radius(2000) // Search within 2km radius
+  .placesType("restaurant") // Default is "restaurant"
+  .apiKey("YOUR_GOOGLE_MAPS_API_KEY") // Or set via NEXT_PUBLIC_GOOGLE_MAPS_API_KEY env var
+  .showLogs() // Print logs to console
+  .showProgress() // Show progress per batch
+  .onFinished("json") // Save results to places_output.json
+  .run();
+```
+
+## Including Temporarily Closed Stores
+By default, the library filters out places with `business_status: "CLOSED_TEMPORARILY"`. To include them:
+
+```typescript
+await getGooglePlaces(location)
+  .allowClosedStores() // Include temporarily closed places
+  .run();
+```
+
+## detailed Usage & Output Formats
+
+### Using a Callback (`onFinished`)
+
+You can process the results directly in your code instead of saving to a file:
+
+```typescript
+await getGooglePlaces(location)
+  .apiKey("YOUR_API_KEY")
+  .onFinished((places) => {
+    console.log(`Found ${places.length} places!`);
+    places.forEach(place => {
+      console.log(`Name: ${place.name}, Rating: ${place.rating}`);
+    });
+  })
+  .run();
+```
+
+### Output Formats
+
+**CSV Output (`.onFinished("csv")`)**
+Creates `places_output.csv` with columns:
+`name, address, rating, user_ratings_total, place_id, lat, lng`
+
+**JSON Output (`.onFinished("json")`)**
+Creates `places_output.json` containing an array of place objects:
+```json
+[
+  {
+    "place_id": "ChIJ...",
+    "name": "Le Example Bistro",
+    "formatted_address": "123 Rue de Example, Paris",
+    "geometry": {
+      "location": {
+        "lat": 48.85,
+        "lng": 2.35
+      }
+    },
+    "types": ["restaurant", "food", "point_of_interest"],
+    "rating": 4.5,
+    "user_ratings_total": 120,
+    "business_status": "OPERATIONAL"
+  }
+]
+```
+
+## Requirements
+- Node.js or Bun environment.
+- A valid Google Cloud API Key with **Places API (New)** or **Places API** enabled.
+
+## License
+MIT

package/dist/api.d.ts

@@ -0,0 +1,3 @@
+import { Coordinate, PlaceResult } from "./types";
+export declare function fetchPlaceFromApi(location: Coordinate, radius: number, type: string, apiKey: string, onProgress?: (count: number) => void, allowClosedStores?: boolean): Promise<PlaceResult[]>;
+//# sourceMappingURL=api.d.ts.map

package/dist/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAElD,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,UAAU,EACpB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACpC,iBAAiB,GAAE,OAAe,GACjC,OAAO,CAAC,WAAW,EAAE,CAAC,CA4DxB"}

package/dist/core.d.ts

@@ -0,0 +1,75 @@
+import { Coordinate, PlaceResult } from "./types";
+type OutputFormat = "csv" | "json" | ((places: PlaceResult[]) => void);
+export declare class PlaceQueryBuilder {
+    private _location;
+    private _radius;
+    private _subRadius;
+    private _minRate;
+    private _limitCount;
+    private _type;
+    private _onFinished?;
+    private _showLogs;
+    private _showProgress;
+    private _apiKey;
+    private _forceQueryClosedStores;
+    constructor(location: Coordinate);
+    /**
+     * Sets the type of place to search for (e.g., 'restaurant', 'cafe').
+     * @param type The place type.
+     */
+    placesType(type: string): this;
+    /**
+     * Sets the search radius in meters.
+     * @param radius Radius in meters (default 4000).
+     */
+    radius(radius: number): this;
+    /**
+     * Sets the minimum rating to filter results (default 4.1).
+     * @param rate Minimum rating.
+     */
+    minRate(rate: number): this;
+    /**
+     * Limits the number of results and optimizes the query by reducing the number of sub-circles searched.
+     * Optimization assumption: ~60 results per sub-circle.
+     * @param max Max number of places to return.
+     */
+    limit(max: number): this;
+    /**
+     * Sets the API Key. If not set here, checks NEXT_PUBLIC_GOOGLE_MAPS_API_KEY env var.
+     * @param key Google Maps API Key.
+     */
+    apiKey(key: string): this;
+    /**
+     * Defines what to do when the process finishes.
+     * @param format 'csv', 'json', or a callback function.
+     */
+    onFinished(format: OutputFormat): this;
+    /**
+     * Enables logging of the process.
+     */
+    showLogs(): this;
+    /**
+     * Enables progress tracking logging.
+     */
+    showProgress(): this;
+    /**
+     * By default, this library filters out the TEMPORARILY_CLOSED stores.
+     * Use this method to allow them to be included in the results.
+     */
+    allowClosedStores(): this;
+    /**
+     * Executes the query process.
+     */
+    run(): Promise<void>;
+    private handleOutput;
+}
+/**
+ *
+ * @param location {latitude: number, longitude: number}
+ * @returns PlaceQueryBuilder
+ *
+ * @version 1.0.8
+ */
+export declare function getGooglePlaces(location: Coordinate): PlaceQueryBuilder;
+export {};
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAElD,KAAK,YAAY,GAAG,KAAK,GAAG,MAAM,GAAG,CAAC,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC,CAAC;AAEvE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,UAAU,CAAe;IACjC,OAAO,CAAC,QAAQ,CAAe;IAC/B,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,WAAW,CAAC,CAAe;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,aAAa,CAAkB;IACvC,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,uBAAuB,CAAkB;gBAErC,QAAQ,EAAE,UAAU;IAMhC;;;OAGG;IACI,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKrC;;;OAGG;IACI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKnC;;;OAGG;IACI,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAKlC;;;;OAIG;IACI,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAK/B;;;OAGG;IACI,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKhC;;;OAGG;IACI,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAK7C;;OAEG;IACI,QAAQ,IAAI,IAAI;IAKvB;;OAEG;IACI,YAAY,IAAI,IAAI;IAK3B;;;OAGG;IACI,iBAAiB,IAAI,IAAI;IAKhC;;OAEG;IACU,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IA0FjC,OAAO,CAAC,YAAY;CA2BrB;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,UAAU,qBAEnD"}

package/dist/geometry.d.ts

@@ -0,0 +1,12 @@
+import { Coordinate } from "./types";
+/**
+ * Generates a list of coordinates for sub-circles that cover a larger circle.
+ * Uses a hexagonal packing strategy to ensure coverage.
+ *
+ * @param center The center of the main search area.
+ * @param radius The radius of the main search area in meters.
+ * @param subRadius The radius of each sub-circle in meters (default 500m).
+ * @returns Array of coordinates for the centers of the sub-circles.
+ */
+export declare function generateSubCircles(center: Coordinate, radius: number, subRadius?: number): Coordinate[];
+//# sourceMappingURL=geometry.d.ts.map

package/dist/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../src/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,MAAY,GACtB,UAAU,EAAE,CAyDd"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { generateSubCircles } from "./geometry";
+export { fetchPlaceFromApi } from "./api";
+export { PlaceQueryBuilder, getGooglePlaces } from "./core";
+export type { Coordinate, PlaceResult } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC5D,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,229 @@
+// src/geometry.ts
+function generateSubCircles(center, radius, subRadius = 500) {
+  if (radius <= subRadius) {
+    return [center];
+  }
+  const coordinates = [];
+  const R = 6371000;
+  const latRad = center.latitude * Math.PI / 180;
+  const step = subRadius * 1.5;
+  const latDegPerMeter = 1 / 111320;
+  const lonDegPerMeter = 1 / (111320 * Math.cos(latRad));
+  const latStep = step * latDegPerMeter;
+  const lonStep = step * lonDegPerMeter;
+  const numSteps = Math.ceil(radius / step);
+  for (let i = -numSteps;i <= numSteps; i++) {
+    for (let j = -numSteps;j <= numSteps; j++) {
+      const xOffset = j * lonStep + (i % 2 === 0 ? 0 : lonStep / 2);
+      const yOffset = i * latStep * (Math.sqrt(3) / 2);
+      const distX = xOffset / lonDegPerMeter;
+      const distY = yOffset / latDegPerMeter;
+      const distance = Math.sqrt(distX * distX + distY * distY);
+      if (distance - subRadius < radius) {
+        coordinates.push({
+          latitude: center.latitude + yOffset,
+          longitude: center.longitude + xOffset
+        });
+      }
+    }
+  }
+  return coordinates;
+}
+// src/api.ts
+async function fetchPlaceFromApi(location, radius, type, apiKey, onProgress, allowClosedStores = false) {
+  const allPlaces = [];
+  const maxPages = 3;
+  const url = new URL("https://maps.googleapis.com/maps/api/place/nearbysearch/json");
+  url.searchParams.append("location", `${location.latitude},${location.longitude}`);
+  url.searchParams.append("radius", radius.toString());
+  url.searchParams.append("type", type);
+  url.searchParams.append("key", apiKey);
+  let nextPageToken = undefined;
+  let pageCount = 0;
+  do {
+    const currentUrl = new URL(url.toString());
+    if (nextPageToken) {
+      currentUrl.searchParams.append("pagetoken", nextPageToken);
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    try {
+      const response = await fetch(currentUrl.toString());
+      const data = await response.json();
+      if (data.status !== "OK" && data.status !== "ZERO_RESULTS") {
+        console.error("Google Places API error:", data.status, data.error_message);
+        break;
+      }
+      if (data.results) {
+        let activePlaces = [];
+        if (!allowClosedStores) {
+          activePlaces = data.results.filter((place) => place.business_status !== "CLOSED_TEMPORARILY");
+          allPlaces.push(...activePlaces);
+        } else {
+          allPlaces.push(...data.results);
+        }
+        if (onProgress) {
+          onProgress(activePlaces.length);
+        }
+      }
+      nextPageToken = data.next_page_token;
+      pageCount++;
+    } catch (error) {
+      console.error("Network error fetching places:", error);
+      break;
+    }
+  } while (nextPageToken && pageCount < maxPages);
+  return allPlaces;
+}
+// src/core.ts
+import { writeFileSync } from "fs";
+
+class PlaceQueryBuilder {
+  _location;
+  _radius = 4000;
+  _subRadius = 500;
+  _minRate = 4.1;
+  _limitCount;
+  _type = "restaurant";
+  _onFinished;
+  _showLogs = false;
+  _showProgress = false;
+  _apiKey;
+  _forceQueryClosedStores = false;
+  constructor(location) {
+    this._location = location;
+    this._apiKey = process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY;
+  }
+  placesType(type) {
+    this._type = type;
+    return this;
+  }
+  radius(radius) {
+    this._radius = radius;
+    return this;
+  }
+  minRate(rate) {
+    this._minRate = rate;
+    return this;
+  }
+  limit(max) {
+    this._limitCount = max;
+    return this;
+  }
+  apiKey(key) {
+    this._apiKey = key;
+    return this;
+  }
+  onFinished(format) {
+    this._onFinished = format;
+    return this;
+  }
+  showLogs() {
+    this._showLogs = true;
+    return this;
+  }
+  showProgress() {
+    this._showProgress = true;
+    return this;
+  }
+  allowClosedStores() {
+    this._forceQueryClosedStores = true;
+    return this;
+  }
+  async run() {
+    if (!this._apiKey) {
+      throw new Error("API Key is required. Set it via .apiKey() or NEXT_PUBLIC_GOOGLE_MAPS_API_KEY env var.");
+    }
+    if (!this._onFinished) {
+      throw new Error("onFinished callback or format is required.");
+    }
+    if (this._showLogs)
+      console.log("Starting Google Places query...");
+    if (this._showLogs)
+      console.log(`Location: ${this._location.latitude}, ${this._location.longitude}`);
+    if (this._showLogs)
+      console.log(`Radius: ${this._radius}m, Sub-radius: ${this._subRadius}m`);
+    let subCircles = generateSubCircles(this._location, this._radius, this._subRadius);
+    if (this._limitCount) {
+      const maxBatches = Math.ceil(this._limitCount / 60);
+      if (subCircles.length > maxBatches) {
+        for (let i = subCircles.length - 1;i > 0; i--) {
+          const j = Math.floor(Math.random() * (i + 1));
+          [subCircles[i], subCircles[j]] = [subCircles[j], subCircles[i]];
+        }
+        subCircles = subCircles.slice(0, maxBatches);
+        if (this._showLogs)
+          console.log(`Optimization: Limiting to ${maxBatches} batches based on limit of ${this._limitCount}`);
+      }
+    }
+    const totalBatches = subCircles.length;
+    if (this._showLogs)
+      console.log(`Generated ${totalBatches} sub-circles for searching.`);
+    const allPlacesMap = new Map;
+    let processedBatches = 0;
+    for (const circle of subCircles) {
+      if (this._showLogs)
+        console.log(`Querying batch ${processedBatches + 1}/${totalBatches} at ${circle.latitude}, ${circle.longitude}...`);
+      const places = await fetchPlaceFromApi(circle, this._subRadius, this._type, this._apiKey, (count) => {}, this._forceQueryClosedStores);
+      for (const place of places) {
+        if (place.place_id) {
+          allPlacesMap.set(place.place_id, place);
+        }
+      }
+      processedBatches++;
+      if (this._showProgress) {
+        const percentage = (processedBatches / totalBatches * 100).toFixed(1);
+        console.log(`Progress: ${percentage}% (${processedBatches}/${totalBatches} batches)`);
+      }
+      await new Promise((r) => setTimeout(r, 200));
+    }
+    let uniquePlaces = Array.from(allPlacesMap.values());
+    uniquePlaces = uniquePlaces.filter((p) => (p.rating || 0) >= this._minRate);
+    if (this._limitCount && uniquePlaces.length > this._limitCount) {
+      uniquePlaces = uniquePlaces.slice(0, this._limitCount);
+    }
+    if (this._showLogs)
+      console.log(`Finished! Found ${uniquePlaces.length} unique places.`);
+    this.handleOutput(uniquePlaces);
+  }
+  handleOutput(places) {
+    if (typeof this._onFinished === "function") {
+      this._onFinished(places);
+    } else if (this._onFinished === "json") {
+      const jsonContent = JSON.stringify(places, null, 2);
+      writeFileSync("places_output.json", jsonContent);
+      if (this._showLogs)
+        console.log("Saved results to places_output.json");
+    } else if (this._onFinished === "csv") {
+      const headers = ["name", "address", "rating", "user_ratings_total", "place_id", "lat", "lng"];
+      const csvContent = [
+        headers.join(","),
+        ...places.map((p) => {
+          return [
+            `"${(p.name || "").replace(/"/g, '""')}"`,
+            `"${(p.formatted_address || "").replace(/"/g, '""')}"`,
+            p.rating || "",
+            p.user_ratings_total || "",
+            p.place_id,
+            p.geometry?.location?.lat || "",
+            p.geometry?.location?.lng || ""
+          ].join(",");
+        })
+      ].join(`
+`);
+      writeFileSync("places_output.csv", csvContent);
+      if (this._showLogs)
+        console.log("Saved results to places_output.csv");
+    }
+  }
+}
+function getGooglePlaces(location) {
+  return new PlaceQueryBuilder(location);
+}
+export {
+  getGooglePlaces,
+  generateSubCircles,
+  fetchPlaceFromApi,
+  PlaceQueryBuilder
+};
+
+//# debugId=98EB28B615C3ED4C64756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../src/geometry.ts", "../src/api.ts", "../src/core.ts"],
+  "sourcesContent": [
+    "import { Coordinate } from \"./types\";\n\n\n/**\n * Generates a list of coordinates for sub-circles that cover a larger circle.\n * Uses a hexagonal packing strategy to ensure coverage.\n * \n * @param center The center of the main search area.\n * @param radius The radius of the main search area in meters.\n * @param subRadius The radius of each sub-circle in meters (default 500m).\n * @returns Array of coordinates for the centers of the sub-circles.\n */\nexport function generateSubCircles(\n  center: Coordinate,\n  radius: number,\n  subRadius: number = 500\n): Coordinate[] {\n  // If the main radius is smaller than the subRadius, just return the center.\n  if (radius <= subRadius) {\n    return [center];\n  }\n\n  const coordinates: Coordinate[] = [];\n  \n  // Earth's radius in meters\n  const R = 6371000;\n  \n  // Convert latitude to radians to calculate longitude offsets correctly\n  const latRad = (center.latitude * Math.PI) / 180;\n  \n  // Distance between centers of hexagonally packed circles to ensure coverage.\n  // Ideally, for r=subRadius, the distance should be approx r * sqrt(3) for tight packing without gaps,\n  // but to be safe and ensure overlap (so we don't miss spots), we can use a slightly tighter spacing.\n  // Using subRadius * 1.5 is a reasonable approximation for coverage with overlap.\n  const step = subRadius * 1.5; \n\n  // Simple grid or spiral generation could work, but let's do a bounding box scan\n  // We scan a square area around the center and keep points within the radius.\n  \n  // Degrees per meter (approximate)\n  const latDegPerMeter = 1 / 111320; \n  const lonDegPerMeter = 1 / (111320 * Math.cos(latRad));\n\n  const latStep = step * latDegPerMeter;\n  const lonStep = step * lonDegPerMeter;\n\n  // Calculate bounds\n  const numSteps = Math.ceil(radius / step);\n  \n  for (let i = -numSteps; i <= numSteps; i++) {\n    for (let j = -numSteps; j <= numSteps; j++) {\n      // Offset based on hexagonal-like grid (shift every other row)\n      const xOffset = j * lonStep + (i % 2 === 0 ? 0 : lonStep / 2);\n      const yOffset = i * latStep * (Math.sqrt(3) / 2); // Hexagonal height factor\n\n      // Calculate distance from center in meters (approx)\n      const distX = xOffset / lonDegPerMeter;\n      const distY = yOffset / latDegPerMeter;\n      const distance = Math.sqrt(distX * distX + distY * distY);\n\n      // We include the circle if its center is within (ParentRadius + epsilon) \n      // or if it covers any part of the parent circle. \n      // Being generous: if distance - subRadius < radius\n      if (distance - subRadius < radius) {\n        coordinates.push({\n          latitude: center.latitude + yOffset,\n          longitude: center.longitude + xOffset\n        });\n      }\n    }\n  }\n\n  return coordinates;\n}\n",
+    "import { Coordinate, PlaceResult } from \"./types\";\n\nexport async function fetchPlaceFromApi(\n  location: Coordinate,\n  radius: number,\n  type: string,\n  apiKey: string,\n  onProgress?: (count: number) => void,\n  allowClosedStores: boolean = false,\n): Promise<PlaceResult[]> {\n  const allPlaces: PlaceResult[] = [];\n  const maxPages = 3;\n  \n  const url = new URL(\n    \"https://maps.googleapis.com/maps/api/place/nearbysearch/json\"\n  );\n  url.searchParams.append(\"location\", `${location.latitude},${location.longitude}`);\n  url.searchParams.append(\"radius\", radius.toString());\n  url.searchParams.append(\"type\", type);\n  // Important: Google Places API does not support explicit pagination by page number,\n  // only by next_page_token.\n  url.searchParams.append(\"key\", apiKey);\n\n  let nextPageToken: string | undefined = undefined;\n  let pageCount = 0;\n\n  do {\n    const currentUrl = new URL(url.toString());\n    if (nextPageToken) {\n      currentUrl.searchParams.append(\"pagetoken\", nextPageToken);\n      // Determine if we need to wait.\n      // Although the user snippet has a wait, let's keep it robust.\n      // Google requires a short delay before the next_page_token becomes valid.\n      await new Promise((resolve) => setTimeout(resolve, 2000));\n    }\n\n    try {\n      const response = await fetch(currentUrl.toString());\n      const data = await response.json();\n\n      if (data.status !== \"OK\" && data.status !== \"ZERO_RESULTS\") {\n        console.error(\"Google Places API error:\", data.status, data.error_message);\n        break;\n      }\n\n      if (data.results) {\n        let activePlaces: PlaceResult[] = [];\n        if (!allowClosedStores) {\n            activePlaces = (data.results as PlaceResult[]).filter(\n                (place) => place.business_status !== \"CLOSED_TEMPORARILY\"\n            );\n            allPlaces.push(...activePlaces);\n        } else {\n            allPlaces.push(...data.results as PlaceResult[]);\n        }\n        if (onProgress) {\n            onProgress(activePlaces.length);\n        }\n      }\n\n      nextPageToken = data.next_page_token;\n      pageCount++;\n    } catch (error) {\n      console.error(\"Network error fetching places:\", error);\n      break;\n    }\n  } while (nextPageToken && pageCount < maxPages);\n\n  return allPlaces;\n}\n",
+    "import { generateSubCircles } from \"./geometry\";\nimport { fetchPlaceFromApi } from \"./api\";\nimport { writeFileSync } from \"fs\";\nimport { Coordinate, PlaceResult } from \"./types\";\n\ntype OutputFormat = \"csv\" | \"json\" | ((places: PlaceResult[]) => void);\n\nexport class PlaceQueryBuilder {\n  private _location: Coordinate;\n  private _radius: number = 4000; // Default 4km\n  private _subRadius: number = 500; // Default 500m\n  private _minRate: number = 4.1;\n  private _limitCount: number | undefined;\n  private _type: string = \"restaurant\";\n  private _onFinished?: OutputFormat;\n  private _showLogs: boolean = false;\n  private _showProgress: boolean = false;\n  private _apiKey: string | undefined;\n  private _forceQueryClosedStores: boolean = false;\n\n  constructor(location: Coordinate) {\n    this._location = location;\n    // Try to load API Key from env if available (Bun loads .env automatically)\n    this._apiKey = process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY;\n  }\n\n  /**\n   * Sets the type of place to search for (e.g., 'restaurant', 'cafe').\n   * @param type The place type.\n   */\n  public placesType(type: string): this {\n    this._type = type;\n    return this;\n  }\n\n  /**\n   * Sets the search radius in meters.\n   * @param radius Radius in meters (default 4000).\n   */\n  public radius(radius: number): this {\n    this._radius = radius;\n    return this;\n  }\n\n  /**\n   * Sets the minimum rating to filter results (default 4.1).\n   * @param rate Minimum rating.\n   */\n  public minRate(rate: number): this {\n    this._minRate = rate;\n    return this;\n  }\n\n  /**\n   * Limits the number of results and optimizes the query by reducing the number of sub-circles searched.\n   * Optimization assumption: ~60 results per sub-circle.\n   * @param max Max number of places to return.\n   */\n  public limit(max: number): this {\n    this._limitCount = max;\n    return this;\n  }\n\n  /**\n   * Sets the API Key. If not set here, checks NEXT_PUBLIC_GOOGLE_MAPS_API_KEY env var.\n   * @param key Google Maps API Key.\n   */\n  public apiKey(key: string): this {\n    this._apiKey = key;\n    return this;\n  }\n\n  /**\n   * Defines what to do when the process finishes.\n   * @param format 'csv', 'json', or a callback function.\n   */\n  public onFinished(format: OutputFormat): this {\n    this._onFinished = format;\n    return this;\n  }\n\n  /**\n   * Enables logging of the process.\n   */\n  public showLogs(): this {\n    this._showLogs = true;\n    return this;\n  }\n\n  /**\n   * Enables progress tracking logging.\n   */\n  public showProgress(): this {\n    this._showProgress = true;\n    return this;\n  }\n\n  /**\n   * By default, this library filters out the TEMPORARILY_CLOSED stores.\n   * Use this method to allow them to be included in the results.\n   */\n  public allowClosedStores(): this {\n    this._forceQueryClosedStores = true;\n    return this;\n  }\n\n  /**\n   * Executes the query process.\n   */\n  public async run(): Promise<void> {\n    if (!this._apiKey) {\n      throw new Error(\"API Key is required. Set it via .apiKey() or NEXT_PUBLIC_GOOGLE_MAPS_API_KEY env var.\");\n    }\n    if (!this._onFinished) {\n      throw new Error(\"onFinished callback or format is required.\");\n    }\n\n    if (this._showLogs) console.log(\"Starting Google Places query...\");\n    if (this._showLogs) console.log(`Location: ${this._location.latitude}, ${this._location.longitude}`);\n    if (this._showLogs) console.log(`Radius: ${this._radius}m, Sub-radius: ${this._subRadius}m`);\n\n    // 1. Generate sub-circles\n    let subCircles = generateSubCircles(this._location, this._radius, this._subRadius);\n    \n    // Optimization: If limit is set, reduce the number of batches\n    if (this._limitCount) {\n      const maxBatches = Math.ceil(this._limitCount / 60);\n      if (subCircles.length > maxBatches) {\n        // Shuffle array to get random circles\n        for (let i = subCircles.length - 1; i > 0; i--) {\n          const j = Math.floor(Math.random() * (i + 1));\n          [subCircles[i], subCircles[j]] = [subCircles[j], subCircles[i]];\n        }\n        // Slice to the max needed matches\n        subCircles = subCircles.slice(0, maxBatches);\n        if (this._showLogs) console.log(`Optimization: Limiting to ${maxBatches} batches based on limit of ${this._limitCount}`);\n      }\n    }\n\n    const totalBatches = subCircles.length;\n\n    if (this._showLogs) console.log(`Generated ${totalBatches} sub-circles for searching.`);\n\n    const allPlacesMap = new Map<string, PlaceResult>();\n    let processedBatches = 0;\n    \n    // 2. Iterate batches\n    // We implement a queue/concurrency limit? The user mentioned \"20 every 2 seconds\". \n    // Since each fetchPlaceFromApi call takes at least ~4s (2s wait between pages, 3 pages max),\n    // and we want to respect rate limits.\n    // Let's run them sequentially to be safe and simple, or with very low concurrency.\n    // Sequential is safest for a \"library\" that shouldn't blast the API.\n\n    for (const circle of subCircles) {\n      if (this._showLogs) console.log(`Querying batch ${processedBatches + 1}/${totalBatches} at ${circle.latitude}, ${circle.longitude}...`);\n      \n      const places = await fetchPlaceFromApi(\n        circle, \n        this._subRadius, \n        this._type, \n        this._apiKey,\n        (count) => {\n             // Optional: finer progress update\n        },\n        this._forceQueryClosedStores\n      );\n\n      for (const place of places) {\n        if (place.place_id) {\n          allPlacesMap.set(place.place_id, place);\n        }\n      }\n\n      processedBatches++;\n      \n      if (this._showProgress) {\n        const percentage = ((processedBatches / totalBatches) * 100).toFixed(1);\n        console.log(`Progress: ${percentage}% (${processedBatches}/${totalBatches} batches)`);\n      }\n\n      // Small delay between batches to be polite to the API?\n      await new Promise(r => setTimeout(r, 200)); \n    }\n\n    let uniquePlaces = Array.from(allPlacesMap.values());\n    \n    // Filter by minRate\n    uniquePlaces = uniquePlaces.filter(p => (p.rating || 0) >= this._minRate);\n\n    // Apply limit\n    if (this._limitCount && uniquePlaces.length > this._limitCount) {\n      uniquePlaces = uniquePlaces.slice(0, this._limitCount);\n    }\n    if (this._showLogs) console.log(`Finished! Found ${uniquePlaces.length} unique places.`);\n\n    // 3. Handle output\n    this.handleOutput(uniquePlaces);\n  }\n\n  private handleOutput(places: PlaceResult[]) {\n    if (typeof this._onFinished === \"function\") {\n      this._onFinished(places);\n    } else if (this._onFinished === \"json\") {\n      const jsonContent = JSON.stringify(places, null, 2);\n      writeFileSync(\"places_output.json\", jsonContent);\n      if (this._showLogs) console.log(\"Saved results to places_output.json\");\n    } else if (this._onFinished === \"csv\") {\n        const headers = [\"name\", \"address\", \"rating\", \"user_ratings_total\", \"place_id\", \"lat\", \"lng\"];\n        const csvContent = [\n            headers.join(\",\"),\n            ...places.map(p => {\n                return [\n                    `\"${(p.name || \"\").replace(/\"/g, '\"\"')}\"`,\n                    `\"${(p.formatted_address || \"\").replace(/\"/g, '\"\"')}\"`,\n                    p.rating || \"\",\n                    p.user_ratings_total || \"\",\n                    p.place_id,\n                    p.geometry?.location?.lat || \"\",\n                    p.geometry?.location?.lng || \"\"\n                ].join(\",\")\n            })\n        ].join(\"\\n\");\n        writeFileSync(\"places_output.csv\", csvContent);\n        if (this._showLogs) console.log(\"Saved results to places_output.csv\");\n    }\n  }\n}\n\n/**\n * \n * @param location {latitude: number, longitude: number}\n * @returns PlaceQueryBuilder\n * \n * @version 1.0.8\n */\nexport function getGooglePlaces(location: Coordinate) {\n  return new PlaceQueryBuilder(location);\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "98EB28B615C3ED4C64756E2164756E21",
+  "names": []
+}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Represents a geographic coordinate.
+ */
+export interface Coordinate {
+    latitude: number;
+    longitude: number;
+}
+export interface PlaceResult {
+    place_id: string;
+    name?: string;
+    formatted_address?: string;
+    geometry?: {
+        location?: {
+            lat(): number;
+            lng(): number;
+        } | {
+            lat: number;
+            lng: number;
+        };
+    };
+    address_components?: Array<{
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }>;
+    formatted_phone_number?: string;
+    website?: string;
+    price_level?: number;
+    rating?: number;
+    types?: string[];
+    timezone?: string;
+    business_status?: string;
+    user_ratings_total?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE;QACT,QAAQ,CAAC,EACL;YACE,GAAG,IAAI,MAAM,CAAC;YACd,GAAG,IAAI,MAAM,CAAC;SACf,GACD;YACE,GAAG,EAAE,MAAM,CAAC;YACZ,GAAG,EAAE,MAAM,CAAC;SACb,CAAC;KACP,CAAC;IACF,kBAAkB,CAAC,EAAE,KAAK,CAAC;QACzB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC,CAAC;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "easy-google-places",
+  "version": "1.0.0",
+  "description": "Query Google Places API with automatic area subdivision to maximize results.",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node --sourcemap=external && tsc --emitDeclarationOnly --outDir dist",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "google-places",
+    "google-maps",
+    "places-api",
+    "restaurants"
+  ],
+  "author": "Eduardo Fazolo",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "^1.3.6"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {}
+}