Remove polyfills for fetch, globalThis, URL and URLSearchParams

We are not targeting browsers, we don't need polyfills for them.
This also removes extra dependencies, which improves compatibility.

Author: zyc9012

scripts/build_npm.ts

@@ -1,4 +1,4 @@
-import { build, emptyDir } from "https://deno.land/x/dnt@0.32.1/mod.ts";
+import { build, emptyDir } from "https://deno.land/x/dnt@0.34.0/mod.ts";
 import { version } from "../version.ts";
 
 await emptyDir("./npm");

src/serpapi.ts

@@ -11,7 +11,6 @@ import {
 } from "./types.ts";
 import {
   _internals,
-  execute,
   extractNextParameters,
   haveParametersChanged,
 } from "./utils.ts";
@@ -90,7 +89,7 @@ export async function getJson<
     },
     timeout,
   );
-  const json = await response.json() as BaseResponse<E>;
+  const json = JSON.parse(response) as BaseResponse<E>;
   const nextParametersFromResponse = await extractNextParameters<E>(json);
   if (
     // https://github.com/serpapi/public-roadmap/issues/562
@@ -137,7 +136,7 @@ export async function getHtml<
 ) {
   const key = validateApiKey(parameters.api_key, true);
   const timeout = validateTimeout(parameters.timeout);
-  const response = await _internals.execute(
+  const html = await _internals.execute(
     SEARCH_PATH,
     {
       ...parameters,
@@ -147,7 +146,6 @@ export async function getHtml<
     },
     timeout,
   );
-  const html = await response.text();
   callback?.(html);
   return html;
 }
@@ -191,7 +189,7 @@ export async function getJsonBySearchId<
     },
     timeout,
   );
-  const json = await response.json() as R;
+  const json = JSON.parse(response) as R;
   callback?.(json);
   return json;
 }
@@ -226,15 +224,14 @@ export async function getHtmlBySearchId(
 ) {
   const key = validateApiKey(parameters.api_key);
   const timeout = validateTimeout(parameters.timeout);
-  const response = await _internals.execute(
+  const html = await _internals.execute(
     `${SEARCH_ARCHIVE_PATH}/${searchId}`,
     {
       api_key: key,
       output: "html",
     },
     timeout,
   );
-  const html = await response.text();
   callback?.(html);
   return html;
 }
@@ -260,10 +257,10 @@ export async function getAccount(
 ) {
   const key = validateApiKey(parameters.api_key);
   const timeout = validateTimeout(parameters.timeout);
-  const response = await execute(ACCOUNT_PATH, {
+  const response = await _internals.execute(ACCOUNT_PATH, {
     api_key: key,
   }, timeout);
-  const info = await response.json() as AccountInformation;
+  const info = JSON.parse(response) as AccountInformation;
   callback?.(info);
   return info;
 }
@@ -289,12 +286,12 @@ export async function getLocations(
   callback?: (locations: Locations) => void,
 ) {
   const timeout = validateTimeout(parameters.timeout);
-  const response = await execute(
+  const response = await _internals.execute(
     LOCATIONS_PATH,
     parameters,
     timeout,
   );
-  const locations = await response.json() as Locations;
+  const locations = JSON.parse(response) as Locations;
   callback?.(locations);
   return locations;
 }

src/utils.ts

@@ -1,10 +1,7 @@
 import type { EngineName, EngineParameters } from "./types.ts";
 import { version } from "../version.ts";
-
-type UrlParameters = Record<
-  string,
-  string | number | boolean | undefined | null
->;
+import https from "node:https";
+import qs from "node:querystring";
 
 /**
  * This `_internals` object is needed to support stubbing/spying of
@@ -14,42 +11,8 @@ type UrlParameters = Record<
  * It's also useful to encapsulate functions that are polyfilled.
  */
 export const _internals = {
-  get fetch() {
-    return (async () => {
-      // Use runtime's `fetch` if it exists, otherwise fallback to `cross-fetch`.
-      return typeof fetch === "function"
-        ? Promise.resolve(fetch)
-        : (await import("npm:cross-fetch@3.1.4")).default;
-    })();
-  },
   execute: execute,
   getBaseUrl: getBaseUrl,
-  get globalThis() {
-    return (async () => {
-      // Use runtime's `globalThis` if it exists, otherwise fallback to `core-js`'s implementation.
-      // dnt-shim-ignore
-      const gt = typeof globalThis !== "undefined" ? globalThis : undefined;
-      return gt !== undefined
-        ? Promise.resolve(gt)
-        : (await import("npm:core-js-pure@3.28.0")).default.globalThis;
-    })();
-  },
-  get URL(): Promise<typeof URL> {
-    return (async () => {
-      // Use runtime's `URL` if it exists, otherwise fallback to `core-js`'s implementation.
-      return typeof URL !== "undefined"
-        ? Promise.resolve(URL)
-        : (await import("npm:core-js-pure@3.28.0")).default.URL;
-    })();
-  },
-  get URLSearchParams(): Promise<typeof URLSearchParams> {
-    return (async () => {
-      // Use runtime's `URLSearchParams` if it exists, otherwise fallback to `core-js`'s implementation.
-      return typeof URLSearchParams !== "undefined"
-        ? Promise.resolve(URLSearchParams)
-        : (await import("npm:core-js-pure@3.28.0")).default.URLSearchParams;
-    })();
-  },
 };
 
 /** Facilitates stubbing in tests, e.g. localhost as the base url */
@@ -65,7 +28,7 @@ type NextParameters<E extends EngineName = EngineName> = {
     >
   ]: string;
 };
-export async function extractNextParameters<E extends EngineName = EngineName>(
+export function extractNextParameters<E extends EngineName = EngineName>(
   json: {
     serpapi_pagination?: { next: string };
     pagination?: { next: string };
@@ -75,7 +38,6 @@ export async function extractNextParameters<E extends EngineName = EngineName>(
     json["pagination"]?.["next"];
 
   if (nextUrlString) {
-    const URL = await _internals.URL;
     const nextUrl = new URL(nextUrlString);
     const nextParameters: Record<string, string> = {};
     for (const [k, v] of nextUrl.searchParams.entries()) {
@@ -100,65 +62,63 @@ export function haveParametersChanged(
   );
 }
 
-export async function getSource() {
+export function getSource() {
   const moduleSource = `serpapi@${version}`;
-  try {
-    const gt = await _internals.globalThis;
-
-    // Check if running in Node.js
-    const nodeVersion = gt.process?.versions?.node;
-    if (nodeVersion) {
-      return `nodejs@${nodeVersion},${moduleSource}`;
-    }
-
-    // Assumes running in Deno instead. https://deno.land/api?s=Deno.version
-    // Deno.version is not shimmed since it's not used when ran in a Node env.
-    const denoVersion = gt.Deno?.version?.deno;
+  if (typeof Deno == "object") {
+    const denoVersion = Deno.version?.deno;
     if (denoVersion) {
       return `deno@${denoVersion},${moduleSource}`;
     }
-
-    return `nodejs,${moduleSource}`;
-  } catch {
-    // If something unexpectedly occurs, revert to "nodejs".
-    return `nodejs,${moduleSource}`;
+    // @ts-ignore: scope of nodejs
+  } else if (typeof process == "object") {
+    // @ts-ignore: scope of nodejs
+    const nodeVersion = process.versions?.node;
+    if (nodeVersion) {
+      return `nodejs@${nodeVersion},${moduleSource}`;
+    }
   }
+  return `nodejs,${moduleSource}`;
 }
 
-export async function buildUrl<P extends UrlParameters>(
+export function buildUrl(
   path: string,
-  parameters: P,
-): Promise<string> {
-  const nonUndefinedParams: [string, string][] = Object.entries(parameters)
-    .filter(([_, value]) => value !== undefined)
-    .map(([key, value]) => [key, `${value}`]);
-  const URLSearchParams = await _internals.URLSearchParams;
-  const searchParams = new URLSearchParams(nonUndefinedParams);
-  return `${_internals.getBaseUrl()}${path}?${searchParams}`;
+  parameters: qs.ParsedUrlQueryInput,
+): string {
+  return `${_internals.getBaseUrl()}${path}?${qs.stringify(parameters)}`;
 }
 
-export async function execute<P extends UrlParameters>(
+export function execute(
   path: string,
-  parameters: P,
+  parameters: qs.ParsedUrlQueryInput,
   timeout: number,
-): Promise<Response> {
-  const url = await buildUrl(path, {
+): Promise<string> {
+  const url = buildUrl(path, {
     ...parameters,
-    source: await getSource(),
+    source: getSource(),
   });
-  // https://github.com/github/fetch/issues/175#issuecomment-216791333
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error("Timeout")), timeout);
-    _internals.fetch.then((fetch) =>
-      fetch(url)
-        .then((res) => {
-          clearTimeout(timer);
-          resolve(res);
-        })
-        .catch((err) => {
-          clearTimeout(timer);
-          reject(err);
-        })
-    );
+    https.get(url, { timeout }, (resp) => {
+      let data = "";
+
+      // A chunk of data has been recieved.
+      resp.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      // The whole response has been received. Print out the result.
+      resp.on("end", () => {
+        try {
+          if (resp.statusCode == 200) {
+            resolve(data);
+          } else {
+            reject(data);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+    }).on("error", (err) => {
+      reject(err);
+    });
   });
 }