@blockcore/dns 0.0.4 → 0.0.5

package/lib/BlockcoreDns.d.ts

@@ -1,17 +1,12 @@
-import { BlockcoreDnsOptions, DnsListEntry, ServiceListEntry } from './types.js';
+import { DnsListEntry, ServiceListEntry } from './types.js';
 export declare class BlockcoreDns {
-    private options;
-    static defaultOptions: BlockcoreDnsOptions;
-    static create(): BlockcoreDns;
+    /** Call this to have data to provide an instance of the Blockcore DNS. */
+    static getDnsServers(): Promise<DnsListEntry[]>;
     private activeServer?;
-    constructor(options?: BlockcoreDnsOptions);
+    constructor(nameserver: string);
     setActiveServer(url: string): void;
-    getDnsServers(): Promise<DnsListEntry[]>;
     getServicesByType(service: 'Indexer' | 'Explorer'): Promise<ServiceListEntry[]>;
     getServicesByTypeAndNetwork(service: 'Indexer' | 'Explorer', symbol: string): Promise<ServiceListEntry[]>;
     getServicesByNetwork(symbol: string): Promise<ServiceListEntry[]>;
     getExternalIP(): Promise<string>;
-    private fetchText;
-    private fetchJson;
-    private fetchUrl;
 }

package/lib/BlockcoreDns.js

@@ -1,74 +1,37 @@
-import fetch from 'node-fetch';
+import { WebRequest } from './Request.js';
 export class BlockcoreDns {
-    constructor(options = BlockcoreDns.defaultOptions) {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: options
-        });
+    constructor(nameserver) {
         Object.defineProperty(this, "activeServer", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        this.setActiveServer(nameserver);
     }
-    static create() {
-        const dns = new BlockcoreDns();
-        return dns;
+    /** Call this to have data to provide an instance of the Blockcore DNS. */
+    static async getDnsServers() {
+        const url = `https://chains.blockcore.net/services/DNS.json`;
+        const servers = await WebRequest.fetchJson(url);
+        return servers;
     }
     setActiveServer(url) {
         this.activeServer = url;
     }
-    async getDnsServers() {
-        const url = `${this.options.baseUrl}/services/DNS.json`;
-        const servers = await this.fetchJson(url);
-        return servers;
-    }
     async getServicesByType(service) {
         const url = `${this.activeServer}/api/dns/services/service/${service}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getServicesByTypeAndNetwork(service, symbol) {
         const url = `${this.activeServer}/api/dns/services/symbol/${symbol}/service/${service}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getServicesByNetwork(symbol) {
         const url = `${this.activeServer}/api/dns/services/symbol/${symbol}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getExternalIP() {
         const url = `${this.activeServer}/api/dns/ipaddress`;
-        return await this.fetchText(url);
-    }
-    async fetchText(url) {
-        const response = await this.fetchUrl(url);
-        return response.text();
-    }
-    async fetchJson(url) {
-        const response = await this.fetchUrl(url);
-        return response.json();
-    }
-    async fetchUrl(url) {
-        return await fetch(url, {
-            method: 'GET',
-            // mode: 'cors',
-            // cache: 'no-cache',
-            // credentials: 'same-origin',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            redirect: 'follow',
-            referrerPolicy: 'no-referrer',
-        });
+        return await WebRequest.fetchText(url);
     }
 }
-Object.defineProperty(BlockcoreDns, "defaultOptions", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        baseUrl: 'https://chains.blockcore.net',
-    }
-});

package/lib/Request.d.ts

@@ -0,0 +1,6 @@
+import { Response } from 'node-fetch';
+export declare class WebRequest {
+    static fetchText(url: string): Promise<string>;
+    static fetchJson<T>(url: string): Promise<T>;
+    static fetchUrl(url: string): Promise<Response>;
+}

package/lib/Request.js

@@ -0,0 +1,24 @@
+import fetch from 'node-fetch';
+export class WebRequest {
+    static async fetchText(url) {
+        const response = await WebRequest.fetchUrl(url);
+        return response.text();
+    }
+    static async fetchJson(url) {
+        const response = await WebRequest.fetchUrl(url);
+        return response.json();
+    }
+    static async fetchUrl(url) {
+        return await fetch(url, {
+            method: 'GET',
+            // mode: 'cors',
+            // cache: 'no-cache',
+            // credentials: 'same-origin',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            redirect: 'follow',
+            referrerPolicy: 'no-referrer',
+        });
+    }
+}

package/lib/types.d.ts

@@ -9,6 +9,3 @@ export interface ServiceListEntry {
     ttl: number;
     online: boolean;
 }
-export interface BlockcoreDnsOptions {
-    baseUrl: string;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcore/dns",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "type": "module",
   "exports": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -52,7 +52,6 @@
     ]
   },
   "dependencies": {
-    "@blockcore/dns": "^0.0.3",
     "@blockcore/identity": "^0.0.1",
     "node-fetch": "^3.2.9"
   }