@stacksjs/whois 0.59.11 → 0.61.0

package/dist/index.js

@@ -338,7 +338,7 @@ async function findWhoIsServer(tld) {
     if (res.ok) {
       const body = await res.text();
       const server = body.match(/whois:\s+(.*)\s+/);
-      if (server)
+      if (server?.[1])
         return server[1];
     }
   } catch (err) {
@@ -349,16 +349,16 @@ async function findWhoIsServer(tld) {
 var shallowCopy = function(obj) {
   if (Array.isArray(obj)) {
     return obj.slice();
-  } else if (typeof obj === "object" && obj !== null) {
+  }
+  if (typeof obj === "object" && obj !== null) {
     const copy = {};
     for (const key in obj) {
       if (Object.prototype.hasOwnProperty.call(obj, key))
         copy[key] = shallowCopy(obj[key]);
     }
     return copy;
-  } else {
-    return obj;
   }
+  return obj;
 };
 var getWhoIsServer = function(tld) {
   return servers_default[tld];
@@ -410,43 +410,42 @@ async function tcpWhois(domain, queryOptions, server, port, encoding, proxy) {
         reject(e);
       }
     });
-  } else {
-    const options = {
-      proxy: {
-        host: proxy.ip,
-        port: proxy.port,
-        type: proxy.type === ProxyType.SOCKS5 ? 5 : 4
-      },
-      command: "connect",
-      destination: {
-        host: server,
-        port
-      }
-    };
-    if (proxy.username && proxy.password) {
-      options.proxy.userId = proxy.username;
-      options.proxy.password = proxy.password;
+  }
+  const options = {
+    proxy: {
+      host: proxy.ip,
+      port: proxy.port,
+      type: proxy.type === ProxyType.SOCKS5 ? 5 : 4
+    },
+    command: "connect",
+    destination: {
+      host: server,
+      port
     }
-    return new Promise((resolve, reject) => {
-      SocksClient.createConnection(options, (err, info) => {
-        if (err) {
-          reject(err);
+  };
+  if (proxy.username && proxy.password) {
+    options.proxy.userId = proxy.username;
+    options.proxy.password = proxy.password;
+  }
+  return new Promise((resolve, reject) => {
+    SocksClient.createConnection(options, (err, info) => {
+      if (err) {
+        reject(err);
+      } else {
+        if (!info)
+          reject(new Error("No socket info received!"));
+        if (queryOptions !== "") {
+          info?.socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`));
         } else {
-          if (!info)
-            reject(new Error("No socket info received!"));
-          if (queryOptions !== "") {
-            info?.socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`));
-          } else {
-            info?.socket.write(encoder.encode(`${domain}\r\n`));
-          }
-          info?.socket.on("data", (data) => {
-            resolve(decoder.decode(data));
-          });
-          info?.socket.resume();
+          info?.socket.write(encoder.encode(`${domain}\r\n`));
         }
-      });
+        info?.socket.on("data", (data) => {
+          resolve(decoder.decode(data));
+        });
+        info?.socket.resume();
+      }
     });
-  }
+  });
 }
 async function whois(domain, parse = false, options = null) {
   let tld;
@@ -490,23 +489,22 @@ async function whois(domain, parse = false, options = null) {
         _raw: rawData,
         parsedData
       };
-    } else {
-      let outputData = null;
-      if (options && options.parseData)
-        outputData = shallowCopy(options.parseData);
-      try {
-        const parsedData = WhoIsParser.parseData(rawData, outputData);
-        return {
-          _raw: rawData,
-          parsedData
-        };
-      } catch (err) {
-        console.error("Error in parsing WhoIs data!", err);
-        return {
-          _raw: rawData,
-          parsedData: null
-        };
-      }
+    }
+    let outputData = null;
+    if (options?.parseData)
+      outputData = shallowCopy(options.parseData);
+    try {
+      const parsedData = WhoIsParser.parseData(rawData, outputData);
+      return {
+        _raw: rawData,
+        parsedData
+      };
+    } catch (err) {
+      console.error("Error in parsing WhoIs data!", err);
+      return {
+        _raw: rawData,
+        parsedData: null
+      };
     }
   } catch (err) {
     return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/whois",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.0",
   "description": "Easily get whois info.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -49,11 +49,11 @@
   },
   "peerDependencies": {
     "node-fetch": "^3.3.2",
-    "socks": "^2.8.1"
+    "socks": "^2.8.3"
   },
   "dependencies": {
     "node-fetch": "^3.3.2",
-    "socks": "^2.8.1"
+    "socks": "^2.8.3"
   },
   "devDependencies": {
     "@stacksjs/development": "latest"

package/src/index.ts

@@ -21,11 +21,9 @@ async function findWhoIsServer(tld: string): Promise<string> {
     if (res.ok) {
       const body = await res.text()
       const server = body.match(/whois:\s+(.*)\s+/)
-      if (server)
-        return server[1]!
+      if (server?.[1]) return server[1]
     }
-  }
-  catch (err) {
+  } catch (err) {
     console.error('Error in getting WhoIs server data from IANA', err)
   }
 
@@ -37,22 +35,20 @@ async function findWhoIsServer(tld: string): Promise<string> {
  * @param obj Object which needs to be copied
  * @returns A copy of the object
  */
-// eslint-disable-next-line ts/no-unnecessary-type-constraint
-function shallowCopy<T extends any>(obj: T): T {
+function shallowCopy<T>(obj: T): T {
   if (Array.isArray(obj)) {
     return obj.slice() as T // Clone the array
   }
-  else if (typeof obj === 'object' && obj !== null) {
+
+  if (typeof obj === 'object' && obj !== null) {
     const copy: any = {}
     for (const key in obj) {
-      if (Object.prototype.hasOwnProperty.call(obj, key))
-        copy[key] = shallowCopy(obj[key])
+      if (Object.prototype.hasOwnProperty.call(obj, key)) copy[key] = shallowCopy(obj[key])
     }
     return copy as T
   }
-  else {
-    return obj // For primitive values, return as is
-  }
+
+  return obj // For primitive values, return as is
 }
 
 /**
@@ -79,8 +75,7 @@ function getTLD(domain: string): keyof typeof SERVERS {
 
   while (true) {
     const domainData = domainStr.split('.')
-    if (domainData.length < 2)
-      break
+    if (domainData.length < 2) break
 
     const tldCheck = domainData.slice(1).join('.') as keyof typeof SERVERS
     const server = SERVERS[tldCheck]
@@ -91,10 +86,8 @@ function getTLD(domain: string): keyof typeof SERVERS {
     domainStr = tldCheck
   }
 
-  if (tld)
-    return tld
+  if (tld) return tld
 
-  // eslint-disable-next-line no-console
   console.debug('TLD is not found in server list. Returning last element after split as TLD!')
 
   const domainData = domain.split('.')
@@ -227,27 +220,22 @@ export class WhoIsParser {
       if (letter === '\n' || (lastLetter === ':' && letter === ' ')) {
         if (lastStr.trim() in outputData) {
           lastField = lastStr.trim()
-        }
-        else if (lastField !== null) {
+        } else if (lastField !== null) {
           const x = lastStr.trim()
           if (x !== '') {
             const obj = outputData[lastField]
-            if (Array.isArray(obj))
-              obj.push(x)
-            else
-              outputData[lastField] = x
+            if (Array.isArray(obj)) obj.push(x)
+            else outputData[lastField] = x
 
             lastField = null
           }
         }
         lastStr = ''
-      }
-      else if (letter !== ':') {
+      } else if (letter !== ':') {
         lastStr = lastStr + letter
       }
       lastLetter = letter as string
-      if (lastStr === 'Record maintained by' || lastStr === '>>>')
-        break
+      if (lastStr === 'Record maintained by' || lastStr === '>>>') break
     }
 
     return outputData
@@ -268,7 +256,7 @@ export class WhoIsParser {
         'Updated Date': '',
         'Registry Expiry Date': '',
         'Domain Status': [],
-        'Registrar': '',
+        Registrar: '',
       }
     }
 
@@ -289,7 +277,14 @@ export class WhoIsParser {
  * @param proxy {@link ProxyData}
  * @returns The {string} WhoIs response for the query. Empty string is returned for errors
  */
-export async function tcpWhois(domain: string, queryOptions: string, server: string, port: number, encoding: string, proxy: ProxyData | null): Promise<string> {
+export async function tcpWhois(
+  domain: string,
+  queryOptions: string,
+  server: string,
+  port: number,
+  encoding: string,
+  proxy: ProxyData | null,
+): Promise<string> {
   const decoder = new TextDecoder(encoding)
   const encoder = new TextEncoder()
 
@@ -298,10 +293,8 @@ export async function tcpWhois(domain: string, queryOptions: string, server: str
     return new Promise((resolve, reject) => {
       try {
         socket.connect({ port, host: server }, () => {
-          if (queryOptions !== '')
-            socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
-          else
-            socket.write(encoder.encode(`${domain}\r\n`))
+          if (queryOptions !== '') socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
+          else socket.write(encoder.encode(`${domain}\r\n`))
         })
 
         socket.on('data', (data) => {
@@ -311,62 +304,53 @@ export async function tcpWhois(domain: string, queryOptions: string, server: str
         socket.on('error', (error) => {
           reject(error)
         })
-      }
-      catch (e) {
+      } catch (e) {
         reject(e)
       }
     })
   }
-  else {
-    const options: SocksClientOptions = {
-      proxy: {
-        host: proxy.ip,
-        port: proxy.port,
-        type: proxy.type === ProxyType.SOCKS5 ? 5 : 4,
-      },
-
-      command: 'connect',
-
-      destination: {
-        host: server,
-        port,
-      },
-    }
 
-    if (proxy.username && proxy.password) {
-      options.proxy.userId = proxy.username
-      options.proxy.password = proxy.password
-    }
+  const options: SocksClientOptions = {
+    proxy: {
+      host: proxy.ip,
+      port: proxy.port,
+      type: proxy.type === ProxyType.SOCKS5 ? 5 : 4,
+    },
 
-    return new Promise((resolve, reject) => {
-      SocksClient.createConnection(options, (err, info) => {
-        if (err) {
-          reject(err)
-        }
-        else {
-          if (!info)
-            reject(new Error('No socket info received!'))
-
-          if (queryOptions !== '') {
-            info?.socket.write(
-              encoder.encode(`${queryOptions} ${domain}\r\n`),
-            )
-          }
-          else {
-            info?.socket.write(
-              encoder.encode(`${domain}\r\n`),
-            )
-          }
+    command: 'connect',
 
-          info?.socket.on('data', (data) => {
-            resolve(decoder.decode(data))
-          })
+    destination: {
+      host: server,
+      port,
+    },
+  }
 
-          info?.socket.resume()
+  if (proxy.username && proxy.password) {
+    options.proxy.userId = proxy.username
+    options.proxy.password = proxy.password
+  }
+
+  return new Promise((resolve, reject) => {
+    SocksClient.createConnection(options, (err, info) => {
+      if (err) {
+        reject(err)
+      } else {
+        if (!info) reject(new Error('No socket info received!'))
+
+        if (queryOptions !== '') {
+          info?.socket.write(encoder.encode(`${queryOptions} ${domain}\r\n`))
+        } else {
+          info?.socket.write(encoder.encode(`${domain}\r\n`))
         }
-      })
+
+        info?.socket.on('data', (data) => {
+          resolve(decoder.decode(data))
+        })
+
+        info?.socket.resume()
+      }
     })
-  }
+  })
 }
 
 /**
@@ -377,7 +361,11 @@ export async function tcpWhois(domain: string, queryOptions: string, server: str
  * @param options {@link WhoIsOptions}
  * @returns {@link WhoIsResponse} Returns a {@link WhoIsResponse} object which contains the raw text and parsed data (if parse is true)
  */
-export async function whois(domain: string, parse: boolean = false, options: WhoIsOptions | null = null): Promise<WhoIsResponse> {
+export async function whois(
+  domain: string,
+  parse = false,
+  options: WhoIsOptions | null = null,
+): Promise<WhoIsResponse> {
   let tld: string
   let port = 43
   let server = ''
@@ -387,8 +375,7 @@ export async function whois(domain: string, parse: boolean = false, options: Who
   if (!options) {
     tld = getTLD(domain)
     proxy = null
-  }
-  else {
+  } else {
     tld = options.tld ? options.tld : getTLD(domain)
     encoding = options.encoding ? options.encoding : 'utf-8'
     proxy = options.proxy ? options.proxy : null
@@ -399,18 +386,15 @@ export async function whois(domain: string, parse: boolean = false, options: Who
   if (server === '') {
     let serverData = getWhoIsServer(tld as keyof typeof SERVERS)
     if (!serverData) {
-      // eslint-disable-next-line no-console
       console.debug(`No WhoIs server found for TLD: ${tld}! Attempting IANA WhoIs database for server!`)
       serverData = await findWhoIsServer(tld)
       if (!serverData) {
-        // eslint-disable-next-line no-console
         console.debug('WhoIs server could not be found!')
         return {
           _raw: '',
           parsedData: null,
         }
       }
-      // eslint-disable-next-line no-console
       console.debug(`WhoIs sever found for ${tld}: ${server}`)
     }
 
@@ -429,28 +413,24 @@ export async function whois(domain: string, parse: boolean = false, options: Who
         parsedData,
       }
     }
-    else {
-      let outputData: any | null = null
-      if (options && options.parseData)
-        outputData = shallowCopy(options.parseData)
 
-      try {
-        const parsedData = WhoIsParser.parseData(rawData, outputData)
-        return {
-          _raw: rawData,
-          parsedData,
-        }
+    let outputData: any | null = null
+    if (options?.parseData) outputData = shallowCopy(options.parseData)
+
+    try {
+      const parsedData = WhoIsParser.parseData(rawData, outputData)
+      return {
+        _raw: rawData,
+        parsedData,
       }
-      catch (err) {
-        console.error('Error in parsing WhoIs data!', err)
-        return {
-          _raw: rawData,
-          parsedData: null,
-        }
+    } catch (err) {
+      console.error('Error in parsing WhoIs data!', err)
+      return {
+        _raw: rawData,
+        parsedData: null,
       }
     }
-  }
-  catch (err) {
+  } catch (err) {
     return {
       _raw: '',
       parsedData: null,
@@ -474,23 +454,29 @@ export function lookup(domain: string, options: WhoIsOptions | null = null): Pro
  * @param options {@link WhoIsOptions}
  * @returns Array of {@link WhoIsResponse} for all the domains. Order is not guaranteed
  */
-export async function batchWhois(domains: string[], parallel: boolean = false, threads: number = 1, parse: boolean = false, options: WhoIsOptions | null = null): Promise<WhoIsResponse[]> {
+export async function batchWhois(
+  domains: string[],
+  parallel = false,
+  threads = 1,
+  parse = false,
+  options: WhoIsOptions | null = null,
+): Promise<WhoIsResponse[]> {
   let response: WhoIsResponse[] = []
 
   if (parallel) {
-    if (threads > domains.length)
-      threads = domains.length
+    if (threads > domains.length) threads = domains.length
 
     for (let i = 0; i < domains.length; i += threads) {
       const batch = domains.slice(i, i + threads)
-      response = await Promise.all(batch.map(async (domain) => {
-        return await whois(domain, parse, options)
-      }))
+      response = await Promise.all(
+        batch.map(async (domain) => {
+          return await whois(domain, parse, options)
+        }),
+      )
     }
-  }
-  else {
+  } else {
     for (let i = 0; i < domains.length; i++) {
-      const res = await whois(domains[i]!, parse, options)
+      const res = await whois(domains[i] as string, parse, options)
       response.push(res)
     }
   }