mybase 1.1.34 → 1.1.36

package/ts/index.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./funcs/getWeekNumber"), exports);
+__exportStar(require("./funcs/Geoip2Paths"), exports);
+__exportStar(require("./funcs/isLocal"), exports);
+__exportStar(require("./funcs/randomString"), exports);
+__exportStar(require("./funcs/utcnow"), exports);
+__exportStar(require("./funcs/validIp"), exports);
+__exportStar(require("./funcs/wait"), exports);
+__exportStar(require("./funcs/fileCacheIsValid"), exports);
+__exportStar(require("./funcs/hash_sha512"), exports);
+__exportStar(require("./funcs/vaultRead"), exports);
+__exportStar(require("./funcs/vaultFill"), exports);
+__exportStar(require("./funcs/asJSON"), exports);
+__exportStar(require("./funcs/promiseTimeout"), exports);
+__exportStar(require("./funcs/randomIP"), exports);
+__exportStar(require("./funcs/ip2int"), exports);
+__exportStar(require("./funcs/int2ip"), exports);
+__exportStar(require("./funcs/randomIP6"), exports);
+__exportStar(require("./funcs/randomTCPPort"), exports);
+__exportStar(require("./funcs/validEmail"), exports);
+__exportStar(require("./funcs/isLoopbackIP"), exports);
+__exportStar(require("./funcs/isLANIp"), exports);
+__exportStar(require("./funcs/getMysql1"), exports);
+__exportStar(require("./funcs/getMysql2"), exports);
+__exportStar(require("./funcs/initMysql2Pool"), exports);
+__exportStar(require("./funcs/randomUTFString"), exports);
+__exportStar(require("./funcs/MaxRuntimeHours"), exports);
+__exportStar(require("./funcs/ensureFolder"), exports);
+// models
+__exportStar(require("./models/Unixtime"), exports);
+__exportStar(require("./models/Timespan"), exports);
+__exportStar(require("./models/IPAddress"), exports);
+//# sourceMappingURL=index.js.map

package/ts/index.test.ts

@@ -0,0 +1,7 @@
+import * as IMPORTS from "./index";
+
+test('exports', () => {
+    for(let fn of Object.values(IMPORTS)) {
+        expect(typeof fn=='function' || typeof fn==='object').toBe(true)
+    }
+})

package/ts/index.ts

@@ -0,0 +1,33 @@
+export * from "./funcs/getWeekNumber"
+export * from "./funcs/Geoip2Paths";
+export * from "./funcs/isLocal"
+export * from "./funcs/randomString"
+export * from "./funcs/utcnow"
+export * from "./funcs/validIp"
+export * from "./funcs/wait"
+export * from "./funcs/fileCacheIsValid"
+export * from "./funcs/hash_sha512"
+export * from "./funcs/vaultRead"
+export * from "./funcs/vaultFill"
+export * from "./funcs/asJSON"
+export * from "./funcs/promiseTimeout"
+export * from "./funcs/randomIP"
+export * from "./funcs/ip2int"
+export * from "./funcs/int2ip"
+export * from "./funcs/randomIP6"
+export * from "./funcs/randomTCPPort"
+export * from "./funcs/validEmail"
+export * from "./funcs/isLoopbackIP"
+export * from "./funcs/isLANIp"
+export * from "./funcs/getMysql1"
+export * from "./funcs/getMysql2"
+export * from "./funcs/initMysql2Pool"
+export * from "./funcs/randomUTFString"
+export * from "./funcs/MaxRuntimeHours"
+export * from "./funcs/ensureFolder"
+
+
+// models
+export * from "./models/Unixtime"
+export * from "./models/Timespan"
+export * from "./models/IPAddress"

package/ts/models/IPAddress.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="@root/ip6addr" />
+import ip6addr, { ToStringOpts } from 'ip6addr';
+export declare class IPAddress {
+    private _ip;
+    static loopback_cidrs4: ip6addr.CIDR[];
+    static loopback_cidrs6: ip6addr.CIDR[];
+    static loopback_cidrs: ip6addr.CIDR[];
+    static lan_cidrs4: ip6addr.CIDR[];
+    static lan_cidrs6: ip6addr.CIDR[];
+    static lan_cidrs: ip6addr.CIDR[];
+    static local_cidrs: ip6addr.CIDR[];
+    static local_cidrs4: ip6addr.CIDR[];
+    static local_cidrs6: ip6addr.CIDR[];
+    constructor(ip: string);
+    abbreviated(): string;
+    toString(opts?: ToStringOpts): string;
+    static validate(ip: string): boolean;
+    static try(ip: string): IPAddress | undefined;
+    static fromString(ip: string): IPAddress;
+    static get Empty(): IPAddress;
+    isLoopbackIP(): boolean;
+    isLANIP(): boolean;
+    isLocalIP(): boolean;
+    partOfCIDR(cidr_networks: ip6addr.CIDR[]): boolean;
+    static partOfCIDR(_ip: string, cidr_networks: ip6addr.CIDR[]): boolean;
+    isPublicIP(): boolean;
+    static unserialize(serializedIpString: string): IPAddress;
+    static randomIP4(): IPAddress;
+    static randomIP6(): IPAddress;
+    static randomCIDRIp(cidr: ip6addr.CIDR[] | 'loopback' | 'lan' | 'local' | 'loopback4' | 'loopback6' | 'lan4' | 'lan6' | 'local4' | 'local6'): IPAddress;
+    serialize(): string;
+    kind(): number;
+    equals(secondIp: IPAddress): boolean;
+    randomPad(): string;
+    normalized(): string;
+    private padIp6;
+    private padIp4;
+    asciiChecksum(): string;
+    checksum1(): string;
+}

package/ts/models/IPAddress.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IPAddress = void 0;
+/// <reference path="./../../ip6addr.d.ts" />
+const debug_1 = __importDefault(require("debug"));
+const __1 = require("./../");
+const ip6addr_1 = __importDefault(require("ip6addr"));
+const net_1 = __importDefault(require("net"));
+const ip6 = require('ip6'); // "url": "https://github.com/elgs/ip6"
+const dbg = (0, debug_1.default)('_IPAddress');
+dbg.enabled = true;
+// need version "ip6": "0.2.7",!!
+class IPAddress {
+    constructor(ip) {
+        if (ip === '-')
+            ip = '0.0.0.0'; // is this really required?
+        try {
+            this._ip = ip6addr_1.default.parse(ip);
+            if (this._ip._attrs.ipv4Mapped) {
+                // we wany to convert it to ipv4
+                this._ip = ip6addr_1.default.parse(this._ip.toString({ format: 'v4' }));
+            }
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new Error(`IPAddress: '${ip}' Error: ${err.message}`);
+            throw err;
+        }
+    }
+    abbreviated() {
+        return this.toString(); // default behaviour of ip6addr
+    }
+    toString(opts = { format: 'auto', zeroElide: false, zeroPad: false }) {
+        return this._ip.toString();
+    }
+    static validate(ip) {
+        try {
+            new IPAddress(ip);
+            return true;
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    static try(ip) {
+        try {
+            return new IPAddress(ip);
+        }
+        catch (_) {
+            return undefined;
+        }
+    }
+    static fromString(ip) {
+        return new IPAddress(ip);
+    }
+    static get Empty() {
+        //The IP address 0.0.0.0 is a non-routable meta-address used to denote an invalid, unknown, 
+        // or non-applicable target. It's not assigned to any individual device. 
+        // It is used in different contexts to mean "any IPv4-enabled network interface" or as a default route
+        return new IPAddress('0.0.0.0');
+    }
+    isLoopbackIP() {
+        return this.partOfCIDR(IPAddress.loopback_cidrs);
+    }
+    isLANIP() {
+        return this.partOfCIDR(IPAddress.lan_cidrs);
+    }
+    isLocalIP() {
+        return this.partOfCIDR(IPAddress.local_cidrs);
+    }
+    partOfCIDR(cidr_networks) {
+        const ipNormalized = this.toString();
+        let ipVersion = net_1.default.isIPv4(ipNormalized) ? 'ipv4' : 'ipv6';
+        for (let cidr of cidr_networks) {
+            if (!cidr)
+                continue;
+            let first = cidr.first();
+            if (first.kind() !== ipVersion)
+                continue;
+            if (cidr.contains(ipNormalized))
+                return true;
+        }
+        return false;
+    }
+    static partOfCIDR(_ip, cidr_networks) {
+        const ip = IPAddress.try(_ip);
+        if (ip === undefined)
+            return false;
+        return ip.partOfCIDR(cidr_networks);
+    }
+    isPublicIP() {
+        return this.toString() !== '0.0.0.0' && !this.isLoopbackIP() && !this.isLANIP();
+    }
+    static unserialize(serializedIpString) {
+        var _a, _b;
+        if (serializedIpString.length === 32) {
+            // we have possible ipv6
+            let ip = (_a = serializedIpString.match(/.{1,4}/g)) === null || _a === void 0 ? void 0 : _a.join(':');
+            if (ip)
+                return new IPAddress(ip);
+        }
+        // we have possible ipv4
+        let ip = (_b = serializedIpString.match(/.{1,3}/g)) === null || _b === void 0 ? void 0 : _b.join('.');
+        if (ip)
+            try {
+                return new IPAddress(ip);
+            }
+            catch (_) { }
+        throw new Error(`Invalid SerializationString: ${serializedIpString}`);
+    }
+    static randomIP4() {
+        return new IPAddress((0, __1.randomIP)());
+    }
+    static randomIP6() {
+        return new IPAddress((0, __1.randomIP6)());
+    }
+    static randomCIDRIp(cidr) {
+        if (cidr === 'loopback')
+            cidr = IPAddress.loopback_cidrs;
+        if (cidr === 'loopback4')
+            cidr = IPAddress.loopback_cidrs4;
+        if (cidr === 'loopback6')
+            cidr = IPAddress.loopback_cidrs6;
+        if (cidr === 'lan')
+            cidr = IPAddress.lan_cidrs;
+        if (cidr === 'lan4')
+            cidr = IPAddress.lan_cidrs4;
+        if (cidr === 'lan6')
+            cidr = IPAddress.lan_cidrs6;
+        if (cidr === 'local')
+            cidr = IPAddress.local_cidrs;
+        if (cidr === 'local4')
+            cidr = IPAddress.local_cidrs4;
+        if (cidr === 'local6')
+            cidr = IPAddress.local_cidrs6;
+        // dbg('randomCIDRIp', cidr)
+        if (cidr.length === 0)
+            throw new Error('CIDR array is empty');
+        // Pick a random CIDR network
+        const network = cidr[Math.floor(Math.random() * cidr.length)];
+        // dbg('randomCIDRIp:network', network)
+        // Get the range of IPs in this CIDR
+        const start = network.first().toBigInt();
+        // dbg('randomCIDRIp:first', network.first().toString(),start)
+        const end = network.last().toBigInt();
+        // dbg('randomCIDRIp:last', network.last().toString(),end)
+        let range = end - start;
+        // dbg('randomCIDRIp:first:last', start, end)
+        // Generate a random Long between the start and end
+        // if start-end > Maximum integer number
+        // we need to use BigInt
+        if (range > BigInt(Number.MAX_SAFE_INTEGER))
+            range = (Number.MAX_SAFE_INTEGER);
+        const randomBigInt = BigInt(Math.floor(Math.random() * (Number(range) + 1))) + start;
+        // dbg('randomBigInt', randomBigInt)
+        // Convert the BigInt back to an IP address
+        const randomIp = ip6addr_1.default.parse(randomBigInt);
+        // dbg('randomCIDRIp', randomIp.toString())
+        return new IPAddress(randomIp.toString());
+    }
+    serialize() {
+        if (this.kind() === 4) {
+            // zero pad ipv4
+            return this._ip.toString().split('.').map((octet) => {
+                return octet.padStart(3, '0');
+            }).join('.').replace(/\./g, '');
+        }
+        // zero pad ipv6 
+        return ip6.normalize(this._ip.toString()).split(':').map((hextet) => {
+            return hextet.padStart(4, '0');
+        }).join(':').replace(/:/g, '');
+    }
+    kind() {
+        return this._ip.kind() === 'ipv6' ? 6 : 4;
+    }
+    equals(secondIp) {
+        return this._ip.compare(secondIp._ip) === 0;
+    }
+    randomPad() {
+        if (this.kind() === 4)
+            return this.padIp4();
+        return this.padIp6();
+    }
+    normalized() {
+        if (this.kind() === 4)
+            return this._ip.toString();
+        return ip6.normalize(this._ip.toString());
+    }
+    padIp6() {
+        const hextets = this.normalized().split(':'); // we need to have the full form
+        const paddedHextets = hextets.map(hextet => {
+            const cleanHextet = Number(`0x${hextet}`).toString(16);
+            const padLength = Math.floor(Math.random() * (4 - cleanHextet.length));
+            return cleanHextet.padStart(padLength + cleanHextet.length, '0');
+        });
+        return paddedHextets.join(':');
+    }
+    padIp4() {
+        const octets = this._ip.toString().split('.');
+        const paddedOctets = octets.map(octet => {
+            const cleanOctet = String(Number(octet));
+            const padLength = Math.floor(Math.random() * (3 - cleanOctet.length));
+            return cleanOctet.padStart(padLength + cleanOctet.length, '0');
+        });
+        return paddedOctets.join('.');
+    }
+    asciiChecksum() {
+        // support ipv4 and ipv6
+        // FNV-1a hash parameters
+        const FNV_PRIME = 0x01000193;
+        const FNV_OFFSET_BASIS = 0x811c9dc5;
+        const CHAR_SET = 'abcdefghijklmnopqrstuvwxyz0123456789';
+        let hash = FNV_OFFSET_BASIS;
+        const ip = this.normalized();
+        for (let i = 0; i < ip.length; i++) {
+            hash ^= ip.charCodeAt(i);
+            hash *= FNV_PRIME;
+            hash >>>= 0; // Ensure hash is always a positive 32-bit integer
+        }
+        // Map the hash to a character in the CHAR_SET
+        const index = hash % CHAR_SET.length;
+        return CHAR_SET.charAt(index);
+    }
+    checksum1() {
+        // this shall check that the ip is ipv4 and return the last octet as checksum
+        if (this.kind() !== 4)
+            return 'x';
+        return this._ip.toString().split('.').pop() || '-';
+    }
+}
+exports.IPAddress = IPAddress;
+IPAddress.loopback_cidrs4 = [
+    ip6addr_1.default.createCIDR('127.0.0.0/8'),
+];
+IPAddress.loopback_cidrs6 = [
+    ip6addr_1.default.createCIDR('::1/128') // yes ipv6 has single address
+];
+IPAddress.loopback_cidrs = IPAddress.loopback_cidrs4.concat(IPAddress.loopback_cidrs6);
+IPAddress.lan_cidrs4 = [
+    ip6addr_1.default.createCIDR('10.0.0.0/8'),
+    ip6addr_1.default.createCIDR('172.16.0.0/12'),
+    ip6addr_1.default.createCIDR('192.168.0.0/16'),
+];
+IPAddress.lan_cidrs6 = [
+    ip6addr_1.default.createCIDR('fd00::/8'), // Reserved by IETF for future use, but not currently in active use.
+    ip6addr_1.default.createCIDR('fc00::/8'), // The range currently in use for local communications within a site or organization.
+];
+IPAddress.lan_cidrs = IPAddress.lan_cidrs4.concat(IPAddress.lan_cidrs6);
+IPAddress.local_cidrs = IPAddress.loopback_cidrs.concat(IPAddress.lan_cidrs);
+IPAddress.local_cidrs4 = IPAddress.loopback_cidrs4.concat(IPAddress.lan_cidrs4);
+IPAddress.local_cidrs6 = IPAddress.loopback_cidrs6.concat(IPAddress.lan_cidrs6);
+//# sourceMappingURL=IPAddress.js.map