npm - jsdomain-parser - Versions diffs - 1.0.6 → 1.0.7 - Mend

jsdomain-parser 1.0.6 → 1.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +1 -0
package/dist/jsdomain-parser.cjs.js +65 -21
package/dist/jsdomain-parser.cjs.min.js +1 -1
package/dist/jsdomain-parser.esm.js +65 -21
package/dist/jsdomain-parser.esm.min.js +1 -1
package/dist/jsdomain-parser.js +65 -21
package/dist/jsdomain-parser.min.js +1 -1
package/{test/test.html → example/example.html} +1 -1
package/index.js +1 -42
package/package.json +4 -2
package/src/parse.js +65 -0
package/src/parseTld.js +12 -2
package/src/parseUrl.js +15 -0
package/src/tlds.json +1 -0
package/test/parse.test.js +152 -0

package/{test/test.html → example/example.html} RENAMED Viewed

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Test Suite</title>
+    <title>Example</title>
     <style>
       #result {

package/index.js CHANGED Viewed

@@ -1,45 +1,4 @@
 const parseTld = require("./src/parseTld.js");
-function parse(url, options = {}) {
-  try {
-    if (!url.startsWith("http")) url = `http://${url}`;
-    const urlObject = new URL(url);
-    const tldData = parseTld(urlObject.hostname, options);
-    let domain = urlObject.hostname;
-    const hostnameParts = urlObject.hostname.split(".");
-    for (let i = hostnameParts.length - 1; i >= 0; i--) {
-      const extended = hostnameParts.slice(i);
-      if (extended.join(".") === tldData.name) {
-        domain = hostnameParts[i - 1] + "." + extended.join(".");
-        break;
-      }
-    }
-    const query = {};
-    for (const [key, value] of urlObject.searchParams.entries()) {
-      query[key] = value;
-    }
-    return {
-      tld: tldData,
-      url: {
-        domain: domain,
-        origin: urlObject.origin,
-        protocol: urlObject.protocol,
-        host: urlObject.host,
-        hostname: urlObject.hostname,
-        port: urlObject.port,
-        pathname: urlObject.pathname,
-        search: urlObject.search,
-        hash: urlObject.hash,
-        query,
-      },
-    };
-  } catch (e) {
-    throw new Error(`Invalid URL: ${e}`);
-  }
-}
+const parse = require("./src/parse.js");
 module.exports = { parse, parseTld };

package/package.json CHANGED Viewed

@@ -1,10 +1,11 @@
 {
   "name": "jsdomain-parser",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Parse URLs to extract TLDs, domain, protocols and more",
   "main": "index.js",
   "scripts": {
-    "build": "rollup -c"
+    "build": "rollup -c",
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -24,6 +25,7 @@
   "license": "MIT",
   "devDependencies": {
     "@rollup/plugin-json": "^6.1.0",
+    "jest": "^29.7.0",
     "rollup": "^2.79.2",
     "rollup-plugin-commonjs": "^10.1.0",
     "rollup-plugin-node-resolve": "^5.2.0",

package/src/parse.js ADDED Viewed

@@ -0,0 +1,65 @@
+const parseTld = require("./parseTld.js");
+const parseUrl = require("./parseUrl.js");
+function parse(url, options = {}) {
+  try {
+    const urlObject = parseUrl(url);
+    if (
+      urlObject.hostname.split(".").filter((i) => i.trim()).length <= 1 &&
+      urlObject.hostname !== "localhost"
+    ) {
+      throw new Error(
+        `Invalid domain name: "${urlObject.hostname}" is not a valid domain.`
+      );
+    }
+    const tldData = parseTld(url, options);
+    let domain = urlObject.hostname;
+    const hostnameParts = urlObject.hostname.split(".");
+    for (let i = hostnameParts.length - 1; i >= 0; i--) {
+      const extended = hostnameParts.slice(i);
+      if (extended.join(".") === tldData.name) {
+        if (hostnameParts[i - 1]) {
+          domain = hostnameParts[i - 1] + "." + extended.join(".");
+        }
+        break;
+      }
+    }
+    const query = {};
+    for (const [key, value] of urlObject.searchParams.entries()) {
+      query[key] = value;
+    }
+    let urlData = {
+      domain: domain,
+      origin: urlObject.origin,
+      protocol: urlObject.protocol,
+      host: urlObject.host,
+      hostname: urlObject.hostname,
+      port: urlObject.port,
+      pathname: urlObject.pathname,
+      search: urlObject.search,
+      hash: urlObject.hash,
+      query,
+    };
+    // handle for protocols that aren't supported by URL constructor
+    if (urlObject.origin === "null") {
+      urlData.origin = urlObject.protocol + "//" + urlObject.hostname;
+    }
+    return {
+      tld: tldData,
+      url: urlData,
+    };
+  } catch (e) {
+    throw new Error(`Invalid URL: ${e.message}`);
+  }
+}
+module.exports = parse;

package/src/parseTld.js CHANGED Viewed

@@ -1,6 +1,7 @@
+const parseUrl = require("./parseUrl");
 const tlds = require("./tlds.json");
-const parseTld = (hostname, options = {}) => {
+const parseTld = (url, options = {}) => {
   const {
     allowUnknown = false,
     allowPrivate = true,
@@ -11,6 +12,12 @@ const parseTld = (hostname, options = {}) => {
     throw new Error("customTlds must be an array");
   }
+  const { hostname } = parseUrl(url);
+  // handle localhost as a special case
+  if (hostname == "localhost" && allowPrivate)
+    return { name: "localhost", length: 1, parts: ["localhost"] };
   const parts = hostname.split(".");
   const customTlds = extendedTlds.map((tld) => [tld, tld.split(".").length]);
@@ -40,7 +47,10 @@ const parseTld = (hostname, options = {}) => {
     }
   }
-  if (detected.length == 0) {
+  // handle case where hostname is an IP address
+  const isIP = /^\d{1,3}(\.\d{1,3}){3}$/.test(hostname);
+  if (detected.length == 0 && !isIP) {
     throw new Error(
       "Could not detect TLD. You can set allowUnknown to true for allowing unknown TLDs."
     );

package/src/parseUrl.js ADDED Viewed

@@ -0,0 +1,15 @@
+const parseUrl = (url) => {
+  if (!url) throw new Error("Invalid domain name");
+  const haveProtocol = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(url);
+  if (!haveProtocol) url = `http://${url}`;
+  const urlObject = new URL(url);
+  // check for hostname validity
+  if (urlObject.hostname.split(".").findIndex((it) => it.trim() == "") >= 0)
+    throw new Error("Invalid domain name");
+  return urlObject;
+};
+module.exports = parseUrl;

package/src/tlds.json CHANGED Viewed

@@ -9776,6 +9776,7 @@
       "meinforum.net": 2,
       "affinitylottery.org.uk": 3,
       "raffleentry.org.uk": 3,
+      "localhost": 1,
       "weeklylottery.org.uk": 3
     }
   }

package/test/parse.test.js ADDED Viewed

@@ -0,0 +1,152 @@
+const parse = require("../src/parse");
+describe("JS Domain Parser Tests", () => {
+  describe("1. General Domain Validation", () => {
+    test("Valid domains with TLDs", () => {
+      expect(parse("example.com")).toBeTruthy();
+      expect(parse("subdomain.example.com")).toBeTruthy();
+      expect(parse("example.co.uk")).toBeTruthy();
+      expect(
+        parse("example.custom", { extendedTlds: ["custom"] })
+      ).toBeTruthy();
+    });
+    test("Domains without TLDs", () => {
+      expect(() => parse("example")).toThrow();
+      expect(parse("localhost").url.hostname).toBe("localhost");
+      expect(() => parse("localhost", { allowPrivate: false })).toThrow();
+    });
+    test("Invalid domains", () => {
+      expect(() => parse("invalid_domain")).toThrow();
+      expect(() => parse("com.")).toThrow();
+      expect(() => parse(".example.com")).toThrow();
+      expect(() => parse("example..com")).toThrow();
+    });
+  });
+  describe("2. Protocol Handling", () => {
+    test("Supported protocols", () => {
+      expect(parse("http://example.com").url.protocol).toBe("http:");
+      expect(parse("https://example.com").url.protocol).toBe("https:");
+      expect(parse("ftp://example.com").url.protocol).toBe("ftp:");
+      expect(parse("ssh://example.com").url.protocol).toBe("ssh:");
+      expect(parse("telnet://example.com").url.protocol).toBe("telnet:");
+    });
+    test("No protocol (assume http)", () => {
+      expect(parse("example.com").url.protocol).toBe("http:");
+      expect(parse("subdomain.example.com").url.protocol).toBe("http:");
+    });
+    test("Invalid protocol cases", () => {
+      expect(() => parse("mailto:")).toThrow();
+      expect(() => parse("ftp://")).toThrow();
+    });
+    test("Non-standard or custom protocols", () => {
+      expect(
+        parse("custom://example.com", { allowUnknown: true }).url.protocol
+      ).toBe("custom:");
+      expect(parse("telnet://192.168.1.1").url.protocol).toBe("telnet:");
+    });
+  });
+  describe("3. Query Strings", () => {
+    test("With query strings", () => {
+      const result = parse("https://example.com?param=value");
+      expect(result.url.query.param).toBe("value");
+    });
+    test("Encoded query strings", () => {
+      const result = parse("https://example.com?param=%20value");
+      expect(result.url.query.param).toBe(" value");
+    });
+    test("Empty query strings", () => {
+      const result = parse("https://example.com?empty=&param=value");
+      expect(result.url.query.empty).toBe("");
+      expect(result.url.query.param).toBe("value");
+    });
+  });
+  describe("4. Path Handling", () => {
+    test("With paths", () => {
+      expect(parse("https://example.com/path").url.pathname).toBe("/path");
+      expect(parse("https://example.com/path/to/resource").url.pathname).toBe(
+        "/path/to/resource"
+      );
+    });
+    test("Edge cases for paths", () => {
+      expect(parse("https://example.com//double-slash").url.pathname).toBe(
+        "//double-slash"
+      );
+      expect(parse("https://example.com/path with spaces").url.pathname).toBe(
+        "/path%20with%20spaces"
+      );
+    });
+  });
+  describe("5. Port Handling", () => {
+    test("Standard ports", () => {
+      expect(parse("http://example.com:80").url.port).toBe("");
+      expect(parse("https://example.com:443").url.port).toBe("");
+    });
+    test("Non-standard ports", () => {
+      expect(parse("http://example.com:8080").url.port).toBe("8080");
+    });
+  });
+  describe("6. TLD Handling", () => {
+    test("Known TLDs", () => {
+      expect(parse("example.com").tld.name).toBe("com");
+      expect(parse("example.org").tld.name).toBe("org");
+    });
+    test("Private TLDs", () => {
+      expect(parse("example.github.io", { allowPrivate: true }).tld.name).toBe(
+        "github.io"
+      );
+      expect(parse("example.github.io", { allowPrivate: false }).tld.name).toBe(
+        "io"
+      );
+    });
+    test("Unknown TLDs", () => {
+      expect(parse("example.unknown", { allowUnknown: true }).tld.name).toBe(
+        "unknown"
+      );
+      expect(() => parse("example.unknown", { allowUnknown: false })).toThrow();
+    });
+  });
+  describe("8. Invalid Inputs", () => {
+    test("Empty strings", () => {
+      expect(() => parse("")).toThrow();
+    });
+    test("Improperly formatted URLs", () => {
+      expect(() => parse("http://")).toThrow();
+      expect(() => parse("https://.")).toThrow();
+    });
+  });
+  describe("9. Nested Subdomains", () => {
+    test("Deeply nested subdomains", () => {
+      const result = parse("a.b.c.example.com");
+      expect(result.url.hostname).toBe("a.b.c.example.com");
+      expect(result.url.domain).toBe("example.com");
+    });
+  });
+  describe("10. Mixed Case", () => {
+    test("Case-insensitive domains", () => {
+      expect(parse("HTTP://EXAMPLE.COM").url.hostname).toBe("example.com");
+      expect(parse("https://Sub.Example.CoM").url.hostname).toBe(
+        "sub.example.com"
+      );
+    });
+  });
+});