@push.rocks/smartnetwork 3.0.2

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smartnetwork',
+    version: '3.0.2',
+    description: 'network diagnostics'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFCQUFxQjtDQUNuQyxDQUFBIn0=

package/dist_ts/helpers/stats.d.ts

@@ -0,0 +1,4 @@
+export declare function average(values: number[]): number;
+export declare function median(values: number[]): number;
+export declare function quartile(values: number[], percentile: number): number;
+export declare function jitter(values: number[]): number;

package/dist_ts/helpers/stats.js

@@ -0,0 +1,33 @@
+export function average(values) {
+    let total = 0;
+    for (let i = 0; i < values.length; i += 1) {
+        total += values[i];
+    }
+    return total / values.length;
+}
+export function median(values) {
+    const half = Math.floor(values.length / 2);
+    values.sort((a, b) => a - b);
+    if (values.length % 2)
+        return values[half];
+    return (values[half - 1] + values[half]) / 2;
+}
+export function quartile(values, percentile) {
+    values.sort((a, b) => a - b);
+    const pos = (values.length - 1) * percentile;
+    const base = Math.floor(pos);
+    const rest = pos - base;
+    if (values[base + 1] !== undefined) {
+        return values[base] + rest * (values[base + 1] - values[base]);
+    }
+    return values[base];
+}
+export function jitter(values) {
+    // Average distance between consecutive latency measurements...
+    let jitters = [];
+    for (let i = 0; i < values.length - 1; i += 1) {
+        jitters.push(Math.abs(values[i] - values[i + 1]));
+    }
+    return average(jitters);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -0,0 +1 @@
+export * from './smartnetwork.classes.smartnetwork.js';

package/dist_ts/index.js

@@ -0,0 +1,2 @@
+export * from './smartnetwork.classes.smartnetwork.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdDQUF3QyxDQUFDIn0=

package/dist_ts/smartnetwork.classes.cloudflarespeed.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartnetwork.plugins.js';
+export declare class CloudflareSpeed {
+    constructor();
+    speedTest(): Promise<{
+        ip: string;
+        serverLocation: {
+            shortId: string;
+            name: string;
+            availableLocations: {
+                [key: string]: string;
+            };
+        };
+        downloadSpeed: string;
+        uploadSpeed: string;
+        maxTime: number;
+        minTime: number;
+        averageTime: number;
+        medianTime: number;
+        jitter: number;
+    }>;
+    measureLatency(): Promise<{
+        maxTime: number;
+        minTime: number;
+        averageTime: number;
+        medianTime: number;
+        jitter: number;
+    }>;
+    measureDownload(bytes: number, iterations: number): Promise<number[]>;
+    measureUpload(bytes: number, iterations: number): Promise<number[]>;
+    measureSpeed(bytes: number, duration: number): Promise<number>;
+    fetchServerLocations(): Promise<{
+        [key: string]: string;
+    }>;
+    get(hostname: string, path: string): Promise<string>;
+    download(bytes: number): Promise<number[]>;
+    upload(bytes: number): Promise<number[]>;
+    request(options: plugins.https.RequestOptions, data?: string): Promise<number[]>;
+    fetchCfCdnCgiTrace(): Promise<{
+        fl: string;
+        h: string;
+        ip: string;
+        ts: string;
+        visit_scheme: string;
+        uag: string;
+        colo: string;
+        http: string;
+        loc: string;
+        tls: string;
+        sni: string;
+        warp: string;
+        gateway: string;
+    }>;
+}

package/dist_ts/smartnetwork.classes.cloudflarespeed.js

@@ -0,0 +1,199 @@
+import * as plugins from './smartnetwork.plugins.js';
+import * as stats from './helpers/stats.js';
+export class CloudflareSpeed {
+    constructor() { }
+    async speedTest() {
+        const latency = await this.measureLatency();
+        const serverLocations = await this.fetchServerLocations();
+        const cgiData = await this.fetchCfCdnCgiTrace();
+        // lets test the download speed
+        const testDown1 = await this.measureDownload(101000, 10);
+        const testDown2 = await this.measureDownload(1001000, 8);
+        const testDown3 = await this.measureDownload(10001000, 6);
+        const testDown4 = await this.measureDownload(25001000, 4);
+        const testDown5 = await this.measureDownload(100001000, 1);
+        const downloadTests = [...testDown1, ...testDown2, ...testDown3, ...testDown4, ...testDown5];
+        const speedDownload = stats.quartile(downloadTests, 0.9).toFixed(2);
+        // lets test the upload speed
+        const testUp1 = await this.measureUpload(11000, 10);
+        const testUp2 = await this.measureUpload(101000, 10);
+        const testUp3 = await this.measureUpload(1001000, 8);
+        const uploadTests = [...testUp1, ...testUp2, ...testUp3];
+        const speedUpload = stats.quartile(uploadTests, 0.9).toFixed(2);
+        return {
+            ...latency,
+            ip: cgiData.ip,
+            serverLocation: {
+                shortId: cgiData.colo,
+                name: serverLocations[cgiData.colo],
+                availableLocations: serverLocations,
+            },
+            downloadSpeed: speedDownload,
+            uploadSpeed: speedUpload,
+        };
+    }
+    async measureLatency() {
+        const measurements = [];
+        for (let i = 0; i < 20; i += 1) {
+            await this.download(1000).then((response) => {
+                // TTFB - Server processing time
+                measurements.push(response[4] - response[0] - response[6]);
+            }, (error) => {
+                console.log(`Error: ${error}`);
+            });
+        }
+        return {
+            maxTime: Math.max(...measurements),
+            minTime: Math.min(...measurements),
+            averageTime: stats.average(measurements),
+            medianTime: stats.median(measurements),
+            jitter: stats.jitter(measurements),
+        };
+    }
+    async measureDownload(bytes, iterations) {
+        const measurements = [];
+        for (let i = 0; i < iterations; i += 1) {
+            await this.download(bytes).then(async (response) => {
+                const transferTime = response[5] - response[4];
+                measurements.push(await this.measureSpeed(bytes, transferTime));
+            }, (error) => {
+                console.log(`Error: ${error}`);
+            });
+        }
+        return measurements;
+    }
+    async measureUpload(bytes, iterations) {
+        const measurements = [];
+        for (let i = 0; i < iterations; i += 1) {
+            await this.upload(bytes).then(async (response) => {
+                const transferTime = response[6];
+                measurements.push(await this.measureSpeed(bytes, transferTime));
+            }, (error) => {
+                console.log(`Error: ${error}`);
+            });
+        }
+        return measurements;
+    }
+    async measureSpeed(bytes, duration) {
+        return (bytes * 8) / (duration / 1000) / 1e6;
+    }
+    async fetchServerLocations() {
+        const res = JSON.parse(await this.get('speed.cloudflare.com', '/locations'));
+        return res.reduce((data, optionsArg) => {
+            // Bypass prettier "no-assign-param" rules
+            const data1 = data;
+            data1[optionsArg.iata] = optionsArg.city;
+            return data1;
+        }, {});
+    }
+    async get(hostname, path) {
+        return new Promise((resolve, reject) => {
+            const req = plugins.https.request({
+                hostname,
+                path,
+                method: 'GET',
+            }, (res) => {
+                const body = [];
+                res.on('data', (chunk) => {
+                    body.push(chunk);
+                });
+                res.on('end', () => {
+                    try {
+                        resolve(Buffer.concat(body).toString());
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                });
+                req.on('error', (err) => {
+                    reject(err);
+                });
+            });
+            req.end();
+        });
+    }
+    async download(bytes) {
+        const options = {
+            hostname: 'speed.cloudflare.com',
+            path: `/__down?bytes=${bytes}`,
+            method: 'GET',
+        };
+        return this.request(options);
+    }
+    async upload(bytes) {
+        const data = '0'.repeat(bytes);
+        const options = {
+            hostname: 'speed.cloudflare.com',
+            path: '/__up',
+            method: 'POST',
+            headers: {
+                'Content-Length': Buffer.byteLength(data),
+            },
+        };
+        return this.request(options, data);
+    }
+    async request(options, data = '') {
+        let started;
+        let dnsLookup;
+        let tcpHandshake;
+        let sslHandshake;
+        let ttfb;
+        let ended;
+        return new Promise((resolve, reject) => {
+            started = plugins.perfHooks.performance.now();
+            const req = plugins.https.request(options, (res) => {
+                res.once('readable', () => {
+                    ttfb = plugins.perfHooks.performance.now();
+                });
+                res.on('data', () => { });
+                res.on('end', () => {
+                    ended = plugins.perfHooks.performance.now();
+                    resolve([
+                        started,
+                        dnsLookup,
+                        tcpHandshake,
+                        sslHandshake,
+                        ttfb,
+                        ended,
+                        parseFloat(res.headers['server-timing'].slice(22)),
+                    ]);
+                });
+            });
+            req.on('socket', (socket) => {
+                socket.on('lookup', () => {
+                    dnsLookup = plugins.perfHooks.performance.now();
+                });
+                socket.on('connect', () => {
+                    tcpHandshake = plugins.perfHooks.performance.now();
+                });
+                socket.on('secureConnect', () => {
+                    sslHandshake = plugins.perfHooks.performance.now();
+                });
+            });
+            req.on('error', (error) => {
+                reject(error);
+            });
+            req.write(data);
+            req.end();
+        });
+    }
+    async fetchCfCdnCgiTrace() {
+        const parseCfCdnCgiTrace = (text) => text
+            .split('\n')
+            .map((i) => {
+            const j = i.split('=');
+            return [j[0], j[1]];
+        })
+            .reduce((data, [k, v]) => {
+            if (v === undefined)
+                return data;
+            // Bypass prettier "no-assign-param" rules
+            const data1 = data;
+            // Object.fromEntries is only supported by Node.js 12 or newer
+            data1[k] = v;
+            return data1;
+        }, {});
+        return this.get('speed.cloudflare.com', '/cdn-cgi/trace').then(parseCfCdnCgiTrace);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartnetwork.classes.cloudflarespeed.js","sourceRoot":"","sources":["../ts/smartnetwork.classes.cloudflarespeed.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartnetwork.classes.smartnetwork.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import * as plugins from './smartnetwork.plugins.js';
+/**
+ * SmartNetwork simplifies actions within the network
+ */
+export declare class SmartNetwork {
+    /**
+     * get network speed
+     * @param measurementTime
+     */
+    getSpeed(): Promise<{
+        ip: string;
+        serverLocation: {
+            shortId: string;
+            name: string;
+            availableLocations: {
+                [key: string]: string;
+            };
+        };
+        downloadSpeed: string;
+        uploadSpeed: string;
+        maxTime: number;
+        minTime: number;
+        averageTime: number;
+        medianTime: number;
+        jitter: number;
+    }>;
+    ping(hostArg: string, timeoutArg?: number): Promise<ReturnType<typeof plugins.smartping.Smartping.prototype.ping>>;
+    /**
+     * returns a promise with a boolean answer
+     * note: false also resolves with false as argument
+     * @param port
+     */
+    isLocalPortUnused(port: number): Promise<boolean>;
+    /**
+     * checks wether a remote port is available
+     * @param domainArg
+     */
+    isRemotePortAvailable(domainArg: string, portArg?: number): Promise<boolean>;
+    getGateways(): Promise<NodeJS.Dict<plugins.os.NetworkInterfaceInfo[]>>;
+    getDefaultGateway(): Promise<{
+        ipv4: plugins.os.NetworkInterfaceInfo;
+        ipv6: plugins.os.NetworkInterfaceInfo;
+    }>;
+    getPublicIps(): Promise<{
+        v4: any;
+        v6: any;
+    }>;
+}

package/dist_ts/smartnetwork.classes.smartnetwork.js

@@ -0,0 +1,123 @@
+import * as plugins from './smartnetwork.plugins.js';
+import { CloudflareSpeed } from './smartnetwork.classes.cloudflarespeed.js';
+/**
+ * SmartNetwork simplifies actions within the network
+ */
+export class SmartNetwork {
+    /**
+     * get network speed
+     * @param measurementTime
+     */
+    async getSpeed() {
+        const cloudflareSpeedInstance = new CloudflareSpeed();
+        const test = await cloudflareSpeedInstance.speedTest();
+        return test;
+    }
+    async ping(hostArg, timeoutArg = 500) {
+        const smartpingInstance = new plugins.smartping.Smartping();
+        const pingResult = await smartpingInstance.ping(hostArg, timeoutArg);
+        return pingResult;
+    }
+    /**
+     * returns a promise with a boolean answer
+     * note: false also resolves with false as argument
+     * @param port
+     */
+    async isLocalPortUnused(port) {
+        const doneIpV4 = plugins.smartpromise.defer();
+        const doneIpV6 = plugins.smartpromise.defer();
+        const net = await import('net'); // creates only one instance of net ;) even on multiple calls
+        // test IPv4 space
+        const ipv4Test = net.createServer();
+        ipv4Test.once('error', (err) => {
+            if (err.code !== 'EADDRINUSE') {
+                doneIpV4.resolve(false);
+                return;
+            }
+            doneIpV4.resolve(false);
+        });
+        ipv4Test.once('listening', () => {
+            ipv4Test.once('close', () => {
+                doneIpV4.resolve(true);
+            });
+            ipv4Test.close();
+        });
+        ipv4Test.listen(port, '0.0.0.0');
+        await doneIpV4.promise;
+        // test IPv6 space
+        const ipv6Test = net.createServer();
+        ipv6Test.once('error', function (err) {
+            if (err.code !== 'EADDRINUSE') {
+                doneIpV6.resolve(false);
+                return;
+            }
+            doneIpV6.resolve(false);
+        });
+        ipv6Test.once('listening', () => {
+            ipv6Test.once('close', () => {
+                doneIpV6.resolve(true);
+            });
+            ipv6Test.close();
+        });
+        ipv6Test.listen(port, '::');
+        // lets wait for the result
+        const resultIpV4 = await doneIpV4.promise;
+        const resultIpV6 = await doneIpV6.promise;
+        const result = resultIpV4 === true && resultIpV6 === true;
+        return result;
+    }
+    /**
+     * checks wether a remote port is available
+     * @param domainArg
+     */
+    async isRemotePortAvailable(domainArg, portArg) {
+        const done = plugins.smartpromise.defer();
+        const domainPart = domainArg.split(':')[0];
+        const port = portArg ? portArg : parseInt(domainArg.split(':')[1], 10);
+        plugins.isopen(domainPart, port, (response) => {
+            console.log(response);
+            if (response[port.toString()].isOpen) {
+                done.resolve(true);
+            }
+            else {
+                done.resolve(false);
+            }
+        });
+        const result = await done.promise;
+        return result;
+    }
+    async getGateways() {
+        const result = plugins.os.networkInterfaces();
+        return result;
+    }
+    async getDefaultGateway() {
+        const defaultGatewayName = await plugins.systeminformation.networkInterfaceDefault();
+        if (!defaultGatewayName) {
+            console.log('Cannot determine default gateway');
+            return null;
+        }
+        const gateways = await this.getGateways();
+        const defaultGateway = gateways[defaultGatewayName];
+        return {
+            ipv4: defaultGateway[0],
+            ipv6: defaultGateway[1],
+        };
+    }
+    async getPublicIps() {
+        return {
+            v4: await plugins.publicIp.publicIpv4({
+                timeout: 1000,
+                onlyHttps: true,
+            }).catch(async (err) => {
+                return null;
+            }),
+            v6: await plugins.publicIp.publicIpv6({
+                timeout: 1000,
+                onlyHttps: true,
+            }).catch(async (err) => {
+                return null;
+            })
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartnetwork.plugins.d.ts

@@ -0,0 +1,12 @@
+import * as os from 'os';
+import * as https from 'https';
+import * as perfHooks from 'perf_hooks';
+export { os, https, perfHooks };
+import * as smartping from '@pushrocks/smartping';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartstring from '@pushrocks/smartstring';
+export { smartpromise, smartping, smartstring };
+import isopen from 'isopen';
+import * as publicIp from 'public-ip';
+import * as systeminformation from 'systeminformation';
+export { isopen, publicIp, systeminformation };

package/dist_ts/smartnetwork.plugins.js

@@ -0,0 +1,18 @@
+// native scope
+import * as os from 'os';
+import * as https from 'https';
+import * as perfHooks from 'perf_hooks';
+export { os, https, perfHooks };
+// @pushrocks scope
+import * as smartping from '@pushrocks/smartping';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartstring from '@pushrocks/smartstring';
+export { smartpromise, smartping, smartstring };
+// @third party scope
+// @ts-ignore
+import isopen from 'isopen';
+// @ts-ignore
+import * as publicIp from 'public-ip';
+import * as systeminformation from 'systeminformation';
+export { isopen, publicIp, systeminformation };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRuZXR3b3JrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydG5ldHdvcmsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxlQUFlO0FBQ2YsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLFNBQVMsTUFBTSxZQUFZLENBQUM7QUFFeEMsT0FBTyxFQUFFLEVBQUUsRUFBRSxLQUFLLEVBQUUsU0FBUyxFQUFFLENBQUM7QUFFaEMsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLFlBQVksTUFBTSx5QkFBeUIsQ0FBQztBQUN4RCxPQUFPLEtBQUssV0FBVyxNQUFNLHdCQUF3QixDQUFDO0FBRXRELE9BQU8sRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLFdBQVcsRUFBRSxDQUFDO0FBRWhELHFCQUFxQjtBQUNyQixhQUFhO0FBQ2IsT0FBTyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQzVCLGFBQWE7QUFDYixPQUFPLEtBQUssUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUN0QyxPQUFPLEtBQUssaUJBQWlCLE1BQU0sbUJBQW1CLENBQUM7QUFFdkQsT0FBTyxFQUFFLE1BQU0sRUFBRSxRQUFRLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQyJ9

package/license

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Lossless GmbH
+Copyright (c) 2020 Tomás Arias
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/npmextra.json

@@ -0,0 +1,17 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smartnetwork",
+      "description": "network diagnostics",
+      "npmPackagename": "@pushrocks/smartnetwork",
+      "license": "MIT"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@push.rocks/smartnetwork",
+  "version": "3.0.2",
+  "private": false,
+  "description": "network diagnostics",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany)"
+  },
+  "devDependencies": {
+    "@gitzone/tsbuild": "^2.1.61",
+    "@gitzone/tsrun": "^1.2.39",
+    "@gitzone/tstest": "^1.0.69",
+    "@pushrocks/smartenv": "^5.0.0",
+    "@pushrocks/tapbundle": "^5.0.3",
+    "@types/node": "^18.11.3"
+  },
+  "dependencies": {
+    "@pushrocks/smartping": "^1.0.7",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/smartstring": "^4.0.2",
+    "@types/default-gateway": "^3.0.1",
+    "isopen": "^1.3.0",
+    "public-ip": "^6.0.1",
+    "systeminformation": "^5.11.9"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
+}

package/readme.md

@@ -0,0 +1,61 @@
+# @pushrocks/smartnetwork
+network diagnostics
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartnetwork)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smartnetwork)
+* [github.com (source mirror)](https://github.com/pushrocks/smartnetwork)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smartnetwork/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/smartnetwork/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/smartnetwork/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/smartnetwork)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/smartnetwork)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@pushrocks/smartnetwork)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/smartnetwork)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/smartnetwork)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+
+## Usage
+
+```typescript
+import * as smartnetwork from 'smartnetwork';
+const testSmartNetwork = new smartnetwork.SmartNetwork();
+const run = async () => {
+  // measure average speed over a period of 5 seconds
+  // the structure of speedResult is self explanatory using TypeScript (or the linked TypeDoc above)
+  const speedResult: smartnetwork.SpeedResult = testSmartNetwork.getSpeed(5000);
+
+  // you can check for local ports before trying to bind to it from your nodejs program
+  const isLocalPortUnused: boolean = await testSmartNetwork.isLocalPortUnused(1234);
+
+  // you can run basic port checks on remote domains.
+  const isRemotePortAvailable: boolean = await testSmartNetwork.isRemotePortAvailable(
+    'google.com:80'
+  );
+
+  // just another way to call for the same thing as above
+  const isRemotePortAvailable: boolean = await testSmartNetwork.isRemotePortAvailable(
+    'google.com',
+    80
+  );
+};
+```
+
+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@pushrocks/smartnetwork',
+  version: '3.0.2',
+  description: 'network diagnostics'
+}

package/ts/helpers/stats.ts

@@ -0,0 +1,43 @@
+export function average(values: number[]) {
+  let total = 0;
+
+  for (let i = 0; i < values.length; i += 1) {
+    total += values[i];
+  }
+
+  return total / values.length;
+}
+
+export function median(values: number[]) {
+  const half = Math.floor(values.length / 2);
+
+  values.sort((a, b) => a - b);
+
+  if (values.length % 2) return values[half];
+
+  return (values[half - 1] + values[half]) / 2;
+}
+
+export function quartile(values: number[], percentile: number) {
+  values.sort((a, b) => a - b);
+  const pos = (values.length - 1) * percentile;
+  const base = Math.floor(pos);
+  const rest = pos - base;
+
+  if (values[base + 1] !== undefined) {
+    return values[base] + rest * (values[base + 1] - values[base]);
+  }
+
+  return values[base];
+}
+
+export function jitter(values: number[]) {
+  // Average distance between consecutive latency measurements...
+  let jitters = [];
+
+  for (let i = 0; i < values.length - 1; i += 1) {
+    jitters.push(Math.abs(values[i] - values[i + 1]));
+  }
+
+  return average(jitters);
+}

package/ts/index.ts

@@ -0,0 +1 @@
+export * from './smartnetwork.classes.smartnetwork.js';

package/ts/smartnetwork.classes.cloudflarespeed.ts

@@ -0,0 +1,258 @@
+import * as plugins from './smartnetwork.plugins.js';
+import * as stats from './helpers/stats.js';
+
+export class CloudflareSpeed {
+  constructor() {}
+
+  public async speedTest() {
+    const latency = await this.measureLatency();
+
+    const serverLocations = await this.fetchServerLocations();
+    const cgiData = await this.fetchCfCdnCgiTrace();
+
+    // lets test the download speed
+    const testDown1 = await this.measureDownload(101000, 10);
+    const testDown2 = await this.measureDownload(1001000, 8);
+    const testDown3 = await this.measureDownload(10001000, 6);
+    const testDown4 = await this.measureDownload(25001000, 4);
+    const testDown5 = await this.measureDownload(100001000, 1);
+    const downloadTests = [...testDown1, ...testDown2, ...testDown3, ...testDown4, ...testDown5];
+    const speedDownload = stats.quartile(downloadTests, 0.9).toFixed(2);
+
+    // lets test the upload speed
+    const testUp1 = await this.measureUpload(11000, 10);
+    const testUp2 = await this.measureUpload(101000, 10);
+    const testUp3 = await this.measureUpload(1001000, 8);
+    const uploadTests = [...testUp1, ...testUp2, ...testUp3];
+    const speedUpload = stats.quartile(uploadTests, 0.9).toFixed(2);
+
+    return {
+      ...latency,
+      ip: cgiData.ip,
+      serverLocation: {
+        shortId: cgiData.colo,
+        name: serverLocations[cgiData.colo],
+        availableLocations: serverLocations,
+      },
+      downloadSpeed: speedDownload,
+      uploadSpeed: speedUpload,
+    };
+  }
+
+  public async measureLatency() {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < 20; i += 1) {
+      await this.download(1000).then(
+        (response) => {
+          // TTFB - Server processing time
+          measurements.push(response[4] - response[0] - response[6]);
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return {
+      maxTime: Math.max(...measurements),
+      minTime: Math.min(...measurements),
+      averageTime: stats.average(measurements),
+      medianTime: stats.median(measurements),
+      jitter: stats.jitter(measurements),
+    };
+  }
+
+  public async measureDownload(bytes: number, iterations: number) {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < iterations; i += 1) {
+      await this.download(bytes).then(
+        async (response) => {
+          const transferTime = response[5] - response[4];
+          measurements.push(await this.measureSpeed(bytes, transferTime));
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return measurements;
+  }
+
+  public async measureUpload(bytes: number, iterations: number) {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < iterations; i += 1) {
+      await this.upload(bytes).then(
+        async (response) => {
+          const transferTime = response[6];
+          measurements.push(await this.measureSpeed(bytes, transferTime));
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return measurements;
+  }
+
+  public async measureSpeed(bytes: number, duration: number) {
+    return (bytes * 8) / (duration / 1000) / 1e6;
+  }
+
+  public async fetchServerLocations(): Promise<{ [key: string]: string }> {
+    const res = JSON.parse(await this.get('speed.cloudflare.com', '/locations'));
+
+    return res.reduce((data: any, optionsArg: { iata: string; city: string }) => {
+      // Bypass prettier "no-assign-param" rules
+      const data1 = data;
+
+      data1[optionsArg.iata] = optionsArg.city;
+      return data1;
+    }, {});
+  }
+
+  public async get(hostname: string, path: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const req = plugins.https.request(
+        {
+          hostname,
+          path,
+          method: 'GET',
+        },
+        (res) => {
+          const body: Array<Buffer> = [];
+          res.on('data', (chunk) => {
+            body.push(chunk);
+          });
+          res.on('end', () => {
+            try {
+              resolve(Buffer.concat(body).toString());
+            } catch (e) {
+              reject(e);
+            }
+          });
+          req.on('error', (err) => {
+            reject(err);
+          });
+        }
+      );
+
+      req.end();
+    });
+  }
+
+  public async download(bytes: number) {
+    const options = {
+      hostname: 'speed.cloudflare.com',
+      path: `/__down?bytes=${bytes}`,
+      method: 'GET',
+    };
+
+    return this.request(options);
+  }
+
+  public async upload(bytes: number) {
+    const data = '0'.repeat(bytes);
+    const options = {
+      hostname: 'speed.cloudflare.com',
+      path: '/__up',
+      method: 'POST',
+      headers: {
+        'Content-Length': Buffer.byteLength(data),
+      },
+    };
+
+    return this.request(options, data);
+  }
+
+  public async request(options: plugins.https.RequestOptions, data = ''): Promise<number[]> {
+    let started: number;
+    let dnsLookup: number;
+    let tcpHandshake: number;
+    let sslHandshake: number;
+    let ttfb: number;
+    let ended: number;
+
+    return new Promise((resolve, reject) => {
+      started = plugins.perfHooks.performance.now();
+      const req = plugins.https.request(options, (res) => {
+        res.once('readable', () => {
+          ttfb = plugins.perfHooks.performance.now();
+        });
+        res.on('data', () => {});
+        res.on('end', () => {
+          ended = plugins.perfHooks.performance.now();
+          resolve([
+            started,
+            dnsLookup,
+            tcpHandshake,
+            sslHandshake,
+            ttfb,
+            ended,
+            parseFloat(res.headers['server-timing'].slice(22) as any),
+          ]);
+        });
+      });
+
+      req.on('socket', (socket) => {
+        socket.on('lookup', () => {
+          dnsLookup = plugins.perfHooks.performance.now();
+        });
+        socket.on('connect', () => {
+          tcpHandshake = plugins.perfHooks.performance.now();
+        });
+        socket.on('secureConnect', () => {
+          sslHandshake = plugins.perfHooks.performance.now();
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.write(data);
+      req.end();
+    });
+  }
+
+  public async fetchCfCdnCgiTrace(): Promise<{
+    fl: string;
+    h: string;
+    ip: string;
+    ts: string;
+    visit_scheme: string;
+    uag: string;
+    colo: string;
+    http: string;
+    loc: string;
+    tls: string;
+    sni: string;
+    warp: string;
+    gateway: string;
+  }> {
+    const parseCfCdnCgiTrace = (text: string) =>
+      text
+        .split('\n')
+        .map((i) => {
+          const j = i.split('=');
+
+          return [j[0], j[1]];
+        })
+        .reduce((data: any, [k, v]) => {
+          if (v === undefined) return data;
+
+          // Bypass prettier "no-assign-param" rules
+          const data1 = data;
+          // Object.fromEntries is only supported by Node.js 12 or newer
+          data1[k] = v;
+
+          return data1;
+        }, {});
+
+    return this.get('speed.cloudflare.com', '/cdn-cgi/trace').then(parseCfCdnCgiTrace);
+  }
+}

package/ts/smartnetwork.classes.smartnetwork.ts

@@ -0,0 +1,137 @@
+import * as plugins from './smartnetwork.plugins.js';
+
+import { CloudflareSpeed } from './smartnetwork.classes.cloudflarespeed.js';
+
+/**
+ * SmartNetwork simplifies actions within the network
+ */
+export class SmartNetwork {
+  /**
+   * get network speed
+   * @param measurementTime
+   */
+  public async getSpeed() {
+    const cloudflareSpeedInstance = new CloudflareSpeed();
+    const test = await cloudflareSpeedInstance.speedTest();
+    return test;
+  }
+
+  public async ping(hostArg: string, timeoutArg: number = 500): Promise<ReturnType<typeof plugins.smartping.Smartping.prototype.ping>> {
+    const smartpingInstance = new plugins.smartping.Smartping();
+    const pingResult = await smartpingInstance.ping(hostArg, timeoutArg);
+    return pingResult;
+  }
+
+  /**
+   * returns a promise with a boolean answer
+   * note: false also resolves with false as argument
+   * @param port
+   */
+  public async isLocalPortUnused(port: number): Promise<boolean> {
+    const doneIpV4 = plugins.smartpromise.defer<boolean>();
+    const doneIpV6 = plugins.smartpromise.defer<boolean>();
+    const net = await import('net'); // creates only one instance of net ;) even on multiple calls
+
+    // test IPv4 space
+    const ipv4Test = net.createServer();
+    ipv4Test.once('error', (err: any) => {
+      if (err.code !== 'EADDRINUSE') {
+        doneIpV4.resolve(false);
+        return;
+      }
+      doneIpV4.resolve(false);
+    });
+    ipv4Test.once('listening', () => {
+      ipv4Test.once('close', () => {
+        doneIpV4.resolve(true);
+      });
+      ipv4Test.close();
+    });
+    ipv4Test.listen(port, '0.0.0.0');
+
+    await doneIpV4.promise;
+
+    // test IPv6 space
+    const ipv6Test = net.createServer();
+    ipv6Test.once('error', function (err: any) {
+      if (err.code !== 'EADDRINUSE') {
+        doneIpV6.resolve(false);
+        return;
+      }
+      doneIpV6.resolve(false);
+    });
+    ipv6Test.once('listening', () => {
+      ipv6Test.once('close', () => {
+        doneIpV6.resolve(true);
+      });
+      ipv6Test.close();
+    });
+    ipv6Test.listen(port, '::');
+
+    // lets wait for the result
+    const resultIpV4 = await doneIpV4.promise;
+    const resultIpV6 = await doneIpV6.promise;
+    const result = resultIpV4 === true && resultIpV6 === true;
+    return result;
+  }
+
+  /**
+   * checks wether a remote port is available
+   * @param domainArg
+   */
+  public async isRemotePortAvailable(domainArg: string, portArg?: number): Promise<boolean> {
+    const done = plugins.smartpromise.defer<boolean>();
+    const domainPart = domainArg.split(':')[0];
+    const port = portArg ? portArg : parseInt(domainArg.split(':')[1], 10);
+
+    plugins.isopen(domainPart, port, (response: any) => {
+      console.log(response);
+      if (response[port.toString()].isOpen) {
+        done.resolve(true);
+      } else {
+        done.resolve(false);
+      }
+    });
+    const result = await done.promise;
+    return result;
+  }
+
+  public async getGateways() {
+    const result = plugins.os.networkInterfaces();
+    return result;
+  }
+
+  public async getDefaultGateway(): Promise<{
+    ipv4: plugins.os.NetworkInterfaceInfo;
+    ipv6: plugins.os.NetworkInterfaceInfo;
+  }> {
+    const defaultGatewayName = await plugins.systeminformation.networkInterfaceDefault();
+    if (!defaultGatewayName) {
+      console.log('Cannot determine default gateway');
+      return null;
+    }
+    const gateways = await this.getGateways();
+    const defaultGateway = gateways[defaultGatewayName];
+    return {
+      ipv4: defaultGateway[0],
+      ipv6: defaultGateway[1],
+    };
+  }
+
+  public async getPublicIps() {
+    return {
+      v4: await plugins.publicIp.publicIpv4({
+        timeout: 1000,
+        onlyHttps: true,
+      }).catch(async (err) => {
+        return null
+      }),
+      v6: await plugins.publicIp.publicIpv6({
+        timeout: 1000,
+        onlyHttps: true,
+      }).catch(async (err) => {
+        return null
+      })
+    };
+  }
+}

package/ts/smartnetwork.plugins.ts

@@ -0,0 +1,22 @@
+// native scope
+import * as os from 'os';
+import * as https from 'https';
+import * as perfHooks from 'perf_hooks';
+
+export { os, https, perfHooks };
+
+// @pushrocks scope
+import * as smartping from '@pushrocks/smartping';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartstring from '@pushrocks/smartstring';
+
+export { smartpromise, smartping, smartstring };
+
+// @third party scope
+// @ts-ignore
+import isopen from 'isopen';
+// @ts-ignore
+import * as publicIp from 'public-ip';
+import * as systeminformation from 'systeminformation';
+
+export { isopen, publicIp, systeminformation };

package/ts/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "noImplicitAny": true
+  }
+}