unping 0.0.0 → 0.0.1

package/README.md

@@ -107,20 +107,31 @@ console.log(`DNS Resolution: ${results[0].alive ? "Success" : "Failed"}`);
 
 ### Hybrid Driver
 
-Smart detection with automatic fallback between multiple methods.
+Smart detection with automatic fallback between multiple drivers.
 
 ```typescript
 import hybridDriver from "unping/drivers/hybrid";
+import tcpDriver from "unping/drivers/tcp";
+import httpDriver from "unping/drivers/http";
+import dnsDriver from "unping/drivers/dns";
 
+// Use default driver configuration (TCP → HTTP → DNS)
 const hybrid = createPingManager({
+  driver: hybridDriver(),
+});
+
+// Or specify custom drivers with specific configurations
+const customHybrid = createPingManager({
   driver: hybridDriver({
-    priority: ["tcp", "http", "dns"], // Try TCP first, then HTTP, then DNS
+    drivers: [
+      tcpDriver({ port: 443 }), // Try HTTPS first
+      httpDriver({ method: "GET" }), // Then HTTP GET
+      dnsDriver({ type: "AAAA" }), // Then IPv6 DNS
+    ],
   }),
 });
 
-// Automatically tries TCP → HTTP → DNS until one succeeds
 const results = await hybrid.ping("example.com");
-console.log(`Detection Method: ${results[0].source || "auto"}`);
 console.log(`Alive: ${results[0].alive}`);
 console.log(`Time: ${results[0].time}ms`);
 ```
@@ -217,10 +228,16 @@ const dns = createPingManager({
 
 ```typescript
 import hybridDriver from "unping/drivers/hybrid";
+import tcpDriver from "unping/drivers/tcp";
+import httpDriver from "unping/drivers/http";
 
 const hybrid = createPingManager({
   driver: hybridDriver({
-    priority: ["http", "tcp", "dns"], // Custom priority order
+    drivers: [
+      tcpDriver({ port: 8080 }), // Custom TCP driver
+      httpDriver({ method: "GET" }), // Custom HTTP driver
+      // Add more drivers as needed
+    ],
   }),
 });
 ```
@@ -324,7 +341,7 @@ interface DNSDriverOptions {
 
 ```typescript
 interface HybridDriverOptions {
-  priority?: Array<"http" | "tcp" | "dns">; // Detection priority (default: ["tcp", "http", "dns"])
+  drivers?: Driver[]; // Array of drivers to try in order (default: [tcp, http, dns])
 }
 ```
 
@@ -342,17 +359,33 @@ The Hybrid Driver provides intelligent network connectivity detection by trying
 - **HTTP Second**: Validates that the service is actually responding at application level (~100-300ms)
 - **DNS Last**: Only checks if domain can be resolved, doesn't guarantee host reachability (~10-20ms)
 
-**Custom Priority Example:**
+**Custom Driver Configuration Example:**
 
 ```typescript
 // For web service monitoring - prioritize HTTP
+import httpDriver from "unping/drivers/http";
+import tcpDriver from "unping/drivers/tcp";
+import dnsDriver from "unping/drivers/dns";
+
 const webMonitor = createPingManager({
-  driver: hybridDriver({ priority: ["http", "tcp", "dns"] }),
+  driver: hybridDriver({
+    drivers: [
+      httpDriver({ method: "HEAD", path: "/health" }),
+      tcpDriver({ port: 80 }),
+      dnsDriver(),
+    ],
+  }),
 });
 
 // For quick connectivity checks - prioritize TCP
 const quickCheck = createPingManager({
-  driver: hybridDriver({ priority: ["tcp", "dns", "http"] }),
+  driver: hybridDriver({
+    drivers: [
+      tcpDriver({ port: 443 }),
+      dnsDriver(),
+      httpDriver({ method: "GET" }),
+    ],
+  }),
 });
 ```
 
@@ -392,8 +425,19 @@ for (const port of ports) {
 ### Network Diagnostics
 
 ```typescript
+import hybridDriver from "unping/drivers/hybrid";
+import tcpDriver from "unping/drivers/tcp";
+import httpDriver from "unping/drivers/http";
+import dnsDriver from "unping/drivers/dns";
+
 const diagnostic = createPingManager({
-  driver: hybridDriver({ priority: ["tcp", "http", "dns"] }),
+  driver: hybridDriver({
+    drivers: [
+      tcpDriver({ port: 80 }),
+      httpDriver({ method: "HEAD" }),
+      dnsDriver(),
+    ],
+  }),
 });
 
 const hosts = ["google.com", "github.com", "cloudflare.com"];

package/dist/drivers/hybrid.cjs

@@ -6,41 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 module.exports = hybridDriver;
 function hybridDriver(options = {}) {
   const {
-    priority = ["tcp", "http", "dns"]
+    drivers: customDrivers
   } = options;
+  const defaultDrivers = getDefaultDrivers();
+  const drivers = customDrivers || defaultDrivers;
   const ping = async (host, opts) => {
     const lastError = new Error("All drivers failed");
-    for (const driverType of priority) {
+    for (const driver of drivers) {
       try {
-        let driver;
-        switch (driverType) {
-          case "http":
-            {
-              const {
-                default: httpDriver
-              } = await Promise.resolve().then(() => require("./http.cjs"));
-              driver = httpDriver(options);
-              break;
-            }
-          case "tcp":
-            {
-              const {
-                default: tcpDriver
-              } = await Promise.resolve().then(() => require("./tcp.cjs"));
-              driver = tcpDriver(options);
-              break;
-            }
-          case "dns":
-            {
-              const {
-                default: dnsDriver
-              } = await Promise.resolve().then(() => require("./dns.cjs"));
-              driver = dnsDriver(options);
-              break;
-            }
-          default:
-            continue;
-        }
         const result = await driver.ping(host, opts);
         return result;
       } catch (error) {
@@ -55,4 +28,22 @@ function hybridDriver(options = {}) {
     options,
     ping
   };
+}
+function getDefaultDrivers() {
+  const {
+    default: tcpDriver
+  } = require("./tcp.cjs");
+  const {
+    default: httpDriver
+  } = require("./http.cjs");
+  const {
+    default: dnsDriver
+  } = require("./dns.cjs");
+  return [tcpDriver({
+    port: 80
+  }), httpDriver({
+    method: "HEAD"
+  }), dnsDriver({
+    type: "A"
+  })];
 }

package/dist/drivers/hybrid.d.ts

@@ -1,6 +1,6 @@
 import type { Driver, DriverOptions } from "../types";
 export interface HybridDriverOptions extends DriverOptions {
-    /** Priority order of drivers (default: ["tcp", "http", "dns"]) */
-    priority?: Array<"http" | "tcp" | "dns">;
+    /** Array of drivers to try in order (default: [tcp, http, dns]) */
+    drivers?: Driver[];
 }
 export default function hybridDriver(options?: HybridDriverOptions): Driver;

package/dist/drivers/hybrid.mjs

@@ -1,29 +1,11 @@
 export default function hybridDriver(options = {}) {
-  const { priority = ["tcp", "http", "dns"] } = options;
+  const { drivers: customDrivers } = options;
+  const defaultDrivers = getDefaultDrivers();
+  const drivers = customDrivers || defaultDrivers;
   const ping = async (host, opts) => {
     const lastError = new Error("All drivers failed");
-    for (const driverType of priority) {
+    for (const driver of drivers) {
       try {
-        let driver;
-        switch (driverType) {
-          case "http": {
-            const { default: httpDriver } = await import("./http.mjs");
-            driver = httpDriver(options);
-            break;
-          }
-          case "tcp": {
-            const { default: tcpDriver } = await import("./tcp.mjs");
-            driver = tcpDriver(options);
-            break;
-          }
-          case "dns": {
-            const { default: dnsDriver } = await import("./dns.mjs");
-            driver = dnsDriver(options);
-            break;
-          }
-          default:
-            continue;
-        }
         const result = await driver.ping(host, opts);
         return result;
       } catch (error) {
@@ -39,3 +21,13 @@ export default function hybridDriver(options = {}) {
     ping
   };
 }
+function getDefaultDrivers() {
+  const { default: tcpDriver } = require("./tcp");
+  const { default: httpDriver } = require("./http");
+  const { default: dnsDriver } = require("./dns");
+  return [
+    tcpDriver({ port: 80 }),
+    httpDriver({ method: "HEAD" }),
+    dnsDriver({ type: "A" })
+  ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unping",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "Unified network ping library with multi-driver support",
   "main": "dist/index.mjs",
   "types": "dist/index.d.ts",