@shaivpidadi/trends-js 0.0.0-beta.2 → 0.0.0-beta.4

package/README.md

@@ -0,0 +1,201 @@
+🚧 WIP: Temporary workaround for [#175](https://github.com/pat310/google-trends-api/issues/175)
+
+# @shaivpidadi/trends-js
+
+A TypeScript library for interacting with the Google Trends API. This package provides a simple and type-safe way to access Google Trends data programmatically.
+
+## Installation
+
+```bash
+npm install @shaivpidadi/trends-js
+```
+
+## Features
+
+- Get daily trending topics
+- Get real-time trending topics
+- Get autocomplete suggestions
+- Explore trends data
+- Get interest by region data
+- TypeScript support
+- Promise-based API
+
+## Usage
+
+### Importing
+
+```typescript
+import GoogleTrendsApi from '@shaivpidadi/trends-js';
+```
+
+### Daily Trends
+
+Get daily trending topics for a specific region:
+
+```typescript
+const result = await GoogleTrendsApi.dailyTrends({ 
+  geo: 'US',  // Default: 'US'
+  lang: 'en'  // Default: 'en'
+});
+
+// Result structure:
+// {
+//   allTrendingStories: Array<...>,
+//   summary: string[]
+// }
+```
+
+### Real-Time Trends
+
+Get real-time trending topics:
+
+```typescript
+const result = await GoogleTrendsApi.realTimeTrends({ 
+  geo: 'US',           // Default: 'US'
+  trendingHours: 4     // Default: 4
+});
+
+// Result structure:
+// {
+//   allTrendingStories: Array<...>,
+//   summary: string[]
+// }
+```
+
+### Autocomplete
+
+Get search suggestions for a keyword:
+
+```typescript
+const suggestions = await GoogleTrendsApi.autocomplete(
+  'bitcoin',           // Keyword to get suggestions for
+  'en-US'              // Language (default: 'en-US')
+);
+
+// Returns: string[]
+```
+
+### Explore
+
+Get widget data for a keyword:
+
+```typescript
+const result = await GoogleTrendsApi.explore({ 
+  keyword: 'bitcoin',
+  geo: 'US',           // Default: 'US'
+  time: 'today 12-m',  // Default: 'today 12-m'
+  category: 0,         // Default: 0
+  property: '',        // Default: ''
+  hl: 'en-US'         // Default: 'en-US'
+});
+
+// Result structure:
+// {
+//   widgets: Array<{
+//     id: string,
+//     request: {...},
+//     token: string
+//   }>
+// }
+```
+
+### Interest by Region
+
+Get interest data by region:
+
+```typescript
+const result = await GoogleTrendsApi.interestByRegion({ 
+  keyword: 'Stock Market',           // Required - string or string[]
+  startTime: new Date('2024-01-01'), // Optional - defaults to 2004-01-01
+  endTime: new Date(),               // Optional - defaults to current date
+  geo: 'US',                         // Optional - string or string[] - defaults to 'US'
+  resolution: 'REGION',              // Optional - 'COUNTRY' | 'REGION' | 'CITY' | 'DMA'
+  hl: 'en-US',                      // Optional - defaults to 'en-US'
+  timezone: -240,                   // Optional - defaults to local timezone
+  category: 0                       // Optional - defaults to 0
+});
+
+// Result structure:
+// {
+//   default: {
+//     geoMapData: Array<{
+//       geoCode: string,
+//       geoName: string,
+//       value: number[],
+//       formattedValue: string[],
+//       maxValueIndex: number,
+//       hasData: boolean[],
+//       coordinates?: {
+//         lat: number,
+//         lng: number
+//       }
+//     }>
+//   }
+// }
+```
+
+Example with multiple keywords and regions:
+
+```typescript
+const result = await GoogleTrendsApi.interestByRegion({ 
+  keyword: ['wine', 'peanuts'],
+  geo: ['US-CA', 'US-VA'],
+  startTime: new Date('2024-01-01'),
+  endTime: new Date(),
+  resolution: 'CITY'
+});
+```
+
+## API Reference
+
+### DailyTrendsOptions
+
+```typescript
+interface DailyTrendsOptions {
+  geo?: string;  // Default: 'US'
+  lang?: string; // Default: 'en'
+}
+```
+
+### RealTimeTrendsOptions
+
+```typescript
+interface RealTimeTrendsOptions {
+  geo: string;
+  trendingHours?: number; // Default: 4
+}
+```
+
+### ExploreOptions
+
+```typescript
+interface ExploreOptions {
+  keyword: string;
+  geo?: string;           // Default: 'US'
+  time?: string;          // Default: 'today 12-m'
+  category?: number;      // Default: 0
+  property?: string;      // Default: ''
+  hl?: string;           // Default: 'en-US'
+}
+```
+
+### InterestByRegionOptions
+
+```typescript
+interface InterestByRegionOptions {
+  keyword: string | string[];        // Required - search term(s)
+  startTime?: Date;                  // Optional - start date
+  endTime?: Date;                    // Optional - end date
+  geo?: string | string[];           // Optional - geocode(s)
+  resolution?: 'COUNTRY' | 'REGION' | 'CITY' | 'DMA'; // Optional
+  hl?: string;                       // Optional - language code
+  timezone?: number;                 // Optional - timezone offset
+  category?: number;                 // Optional - category number
+}
+```
+
+## Development
+
+### Building
+
+```

package/lib/constants.js

@@ -23,7 +23,7 @@ exports.GOOGLE_TRENDS_MAPPER = {
     },
     ["explore" /* GoogleTrendsEndpoints.explore */]: {
         path: '/trends/api/explore',
-        method: 'GET',
+        method: 'POST',
         host: GOOGLE_TRENDS_BASE_URL,
         url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/explore`,
         headers: {},

package/lib/helpers/googleTrendsAPI.d.ts

@@ -4,7 +4,7 @@ export declare class GoogleTrendsApi {
     dailyTrends({ geo, lang }: DailyTrendingTopicsOptions): Promise<DailyTrendingTopics>;
     realTimeTrends({ geo, trendingHours }: RealTimeTrendsOptions): Promise<DailyTrendingTopics>;
     explore({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<ExploreResponse>;
-    interestByRegion({ keyword, geo, time, resolution, hl, }: InterestByRegionOptions): Promise<InterestByRegionResponse>;
+    interestByRegion({ keyword, startTime, endTime, geo, resolution, hl, timezone, category }: InterestByRegionOptions): Promise<InterestByRegionResponse>;
 }
 declare const _default: GoogleTrendsApi;
 export default _default;

package/lib/helpers/googleTrendsAPI.js

@@ -120,44 +120,68 @@ class GoogleTrendsApi {
             }
         });
     }
-    interestByRegion({ keyword, geo = 'US', time = 'today 12-m', resolution = 'REGION', hl = 'en-US', }) {
+    // 
+    interestByRegion({ keyword, startTime = new Date('2004-01-01'), endTime = new Date(), geo = 'US', resolution = 'REGION', hl = 'en-US', timezone = new Date().getTimezoneOffset(), category = 0 }) {
         return __awaiter(this, void 0, void 0, function* () {
-            // First get the widget token from explore
-            const exploreResponse = yield this.explore({ keyword, geo, time, hl });
-            const widget = exploreResponse.widgets.find((w) => w.id === 'GEO_MAP_0');
+            const formatDate = (date) => {
+                return date.toISOString().split('T')[0];
+            };
+            const formatTrendsDate = (date) => {
+                const pad = (n) => n.toString().padStart(2, '0');
+                const yyyy = date.getFullYear();
+                const mm = pad(date.getMonth() + 1);
+                const dd = pad(date.getDate());
+                const hh = pad(date.getHours());
+                const min = pad(date.getMinutes());
+                const ss = pad(date.getSeconds());
+                return `${yyyy}-${mm}-${dd}T${hh}\\:${min}\\:${ss}`;
+            };
+            const getDateRangeParam = (date) => {
+                const yesterday = new Date(date);
+                yesterday.setDate(date.getDate() - 1);
+                const formattedStart = formatTrendsDate(yesterday);
+                const formattedEnd = formatTrendsDate(date);
+                return `${formattedStart} ${formattedEnd}`;
+            };
+            const exploreResponse = yield this.explore({
+                keyword: Array.isArray(keyword) ? keyword[0] : keyword,
+                geo: Array.isArray(geo) ? geo[0] : geo,
+                time: `${getDateRangeParam(startTime)} ${getDateRangeParam(endTime)}`,
+                category,
+                hl
+            });
+            const widget = exploreResponse.widgets.find(w => w.id === 'GEO_MAP');
             if (!widget) {
                 return { default: { geoMapData: [] } };
             }
             const options = Object.assign(Object.assign({}, constants_1.GOOGLE_TRENDS_MAPPER["interestByRegion" /* GoogleTrendsEndpoints.interestByRegion */]), { qs: {
                     hl,
-                    tz: '240',
+                    tz: timezone.toString(),
                     req: JSON.stringify({
-                        geo: { country: geo },
-                        comparisonItem: [
-                            {
-                                time,
+                        geo: {
+                            country: Array.isArray(geo) ? geo[0] : geo
+                        },
+                        comparisonItem: [{
+                                time: `${formatDate(startTime)} ${formatDate(endTime)}`,
                                 complexKeywordsRestriction: {
-                                    keyword: [
-                                        {
+                                    keyword: [{
                                             type: 'BROAD',
-                                            value: keyword,
-                                        },
-                                    ],
-                                },
-                            },
-                        ],
+                                            value: Array.isArray(keyword) ? keyword[0] : keyword
+                                        }]
+                                }
+                            }],
                         resolution,
                         locale: hl,
                         requestOptions: {
                             property: '',
-                            backend: 'IZG',
-                            category: 0,
+                            backend: 'CM',
+                            category
                         },
                         userConfig: {
-                            userType: 'USER_TYPE_SCRAPER',
-                        },
+                            userType: 'USER_TYPE_LEGIT_USER'
+                        }
                     }),
-                    token: widget.token,
+                    token: widget.token
                 } });
             try {
                 const response = yield (0, request_1.request)(options.url, options);
@@ -167,7 +191,6 @@ class GoogleTrendsApi {
                 return data;
             }
             catch (error) {
-                console.error('Interest by region request failed:', error);
                 return { default: { geoMapData: [] } };
             }
         });

package/lib/helpers/request.d.ts

@@ -1 +1,5 @@
-export declare const request: (url: string, options: RequestInit) => Promise<any>;
+export declare const request: (url: string, options: {
+    method?: string;
+    qs?: Record<string, any>;
+    body?: string;
+}) => Promise<Response>;

package/lib/helpers/request.js

@@ -8,10 +8,75 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.request = void 0;
+const https_1 = __importDefault(require("https"));
+const querystring_1 = __importDefault(require("querystring"));
+let cookieVal;
+function rereq(options) {
+    return new Promise((resolve, reject) => {
+        const req = https_1.default.request(options, (res) => {
+            let chunk = '';
+            res.on('data', (data) => {
+                chunk += data;
+            });
+            res.on('end', () => {
+                resolve(chunk.toString());
+            });
+        });
+        req.on('error', (e) => {
+            reject(e);
+        });
+        req.end();
+    });
+}
 const request = (url, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield fetch(url, options);
-    return response;
+    const parsedUrl = new URL(url);
+    const requestOptions = {
+        host: parsedUrl.host,
+        method: options.method || 'POST',
+        path: `${parsedUrl.pathname}${options.qs ? '?' + querystring_1.default.stringify(options.qs) : ''}`,
+        headers: {}
+    };
+    if (cookieVal) {
+        requestOptions.headers = { 'cookie': cookieVal };
+    }
+    const response = yield new Promise((resolve, reject) => {
+        const req = https_1.default.request(requestOptions, (res) => {
+            let chunk = '';
+            res.on('data', (data) => {
+                chunk += data;
+            });
+            res.on('end', () => __awaiter(void 0, void 0, void 0, function* () {
+                if (res.statusCode === 429 && res.headers['set-cookie']) {
+                    cookieVal = res.headers['set-cookie'][0].split(';')[0];
+                    requestOptions.headers = { 'cookie': cookieVal };
+                    try {
+                        const retryResponse = yield rereq(requestOptions);
+                        resolve(retryResponse);
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                }
+                else {
+                    resolve(chunk.toString());
+                }
+            }));
+        });
+        if (options.body) {
+            req.write(options.body);
+        }
+        req.on('error', (e) => {
+            reject(e);
+        });
+        req.end();
+    });
+    return {
+        text: () => Promise.resolve(response)
+    };
 });
 exports.request = request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaivpidadi/trends-js",
-  "version": "0.0.0-beta.2",
+  "version": "0.0.0-beta.4",
   "description": "Google Trends API for Node.js",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",