mybase 1.1.2 → 1.1.4

package/mybase.js

@@ -1,3 +1,4 @@
+const { ipRangeCheck } = require('ip-range-check')
 const aesjs = require("aes-js")
 const debug = require('debug')('mybase')
 const os = require('os')
@@ -7,7 +8,6 @@ const net = require('net')
 const chalk = require('chalk')
 const punycode = require('punycode');
 const _validURL = require('@7c/validurl')
-const { match } = require('assert');
 const validator = require('validator')
 const sha512 = require('js-sha512')
 const ip6addr = require('ip6addr')
@@ -178,7 +178,7 @@ function validURL(host) {
     return _validURL(host)
 }
 
-function asJSON(str) {
+function asJSON(str) { // ported
     if (!str || typeof str!=='string') return false
     try { return JSON.parse(str)}catch(_) {}
     return false
@@ -574,7 +574,7 @@ function validUUID4(uuid) {
     return new RegExp(/^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i).test(uuid)
 }
 
-function promiseTimeout(ms, promise) {
+function promiseTimeout(ms, promise) { // ported
     // Create a promise that rejects in <ms> milliseconds
     let timeout = new Promise((resolve, reject) => {
         let id = setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mybase",
-  "version": "1.1.2",
+  "version": "1.1.4",
   "description": "",
   "main": "mybase.js",
   "scripts": {

package/ts/funcs/asJSON.test.js

@@ -0,0 +1,72 @@
+const { asJSON } = require('./asJSON')
+
+describe('asJSON', () => {
+    // Returns parsed JSON object when valid JSON string is passed as input.
+    it('should return parsed JSON object when valid JSON string is passed as input', () => {
+        const inputString = '{"name": "John", "age": 30}';
+        const expectedOutput = { name: "John", age: 30 };
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when empty string is passed as input.
+    it('should return false when empty string is passed as input', () => {
+        const inputString = "";
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when non-string input is passed.
+    it('should return false when non-string input is passed', () => {
+        const inputString = 123;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when null is passed as input.
+    it('should return false when null is passed as input', () => {
+        const inputString = null;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when undefined is passed as input.
+    it('should return false when undefined is passed as input', () => {
+        const inputString = undefined;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when NaN is passed as input.
+    it('should return false when NaN is passed as input', () => {
+        const inputString = NaN;
+        const expectedOutput = false;
+        const result = asJSON(inputString);
+        expect(result).toEqual(expectedOutput);
+    });
+
+    // Returns false when invalid JSON string is passed as input.
+    it('should return false when invalid JSON string is passed as input', () => {
+      const inputString = 'invalid json';
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+
+    // Returns false when Infinity is passed as input.
+    it('should return false when Infinity is passed as input', () => {
+      const inputString = 'Infinity';
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+
+    // Returns false when input string contains a single quote.
+    it('should return false when input string contains a single quote', () => {
+      const inputString = "{'name': 'John'}";
+      const result = asJSON(inputString);
+      expect(result).toBe(false);
+    });
+});

package/ts/funcs/asJSON.ts

@@ -0,0 +1,6 @@
+
+export function asJSON(inputString: string): any | boolean {
+    if (!inputString || typeof inputString !== 'string') return false
+    try { return JSON.parse(inputString) } catch (_) { }
+    return false
+}

package/ts/funcs/promiseTimeout.test.js

@@ -0,0 +1,104 @@
+const { promiseTimeout } = require('./promiseTimeout');
+
+describe('promiseTimeout', () => {
+
+  // Returns a promise that resolves when inputPromise resolves before the timeout.
+  it('should resolve when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise rejects after the timeout.
+  it('should reject with onTimeout when inputPromise rejects after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 200);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that rejects with onTimeout when inputPromise is pending after the timeout.
+  it('should reject with onTimeout when inputPromise is pending after the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(100, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with inputPromise value when inputPromise resolves before the timeout.
+  it('should resolve with inputPromise value when inputPromise resolves before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve) => {
+      setTimeout(() => {
+        resolve('Resolved');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe('Resolved');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise rejects before the timeout.
+  it('should reject with inputPromise value when inputPromise rejects before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject('Rejected');
+      }, 100);
+    });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('Rejected');
+  });
+
+  // Returns a promise that rejects with inputPromise value when inputPromise is pending before the timeout.
+  it('should reject with inputPromise value when inputPromise is pending before the timeout', () => {
+    // Arrange
+    const inputPromise = new Promise(() => { });
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).rejects.toBe('TIMEDOUT');
+  });
+
+  // Returns a promise that resolves with undefined when inputPromise is undefined.
+  it('should resolve with undefined when inputPromise is undefined', () => {
+    // Arrange
+    const inputPromise = undefined;
+
+    // Act
+    const resultPromise = promiseTimeout(200, inputPromise);
+
+    // Assert
+    return expect(resultPromise).resolves.toBe(undefined);
+  });
+});

package/ts/funcs/promiseTimeout.ts

@@ -0,0 +1,19 @@
+
+
+
+
+export function promiseTimeout(miliseconds:number, inputPromise:Promise<any>, onTimeout:any='TIMEDOUT') { // ported
+    // Create a promise that rejects in <miliseconds> milliseconds
+    let timeout = new Promise((resolve, reject) => {
+        let stID = setTimeout(() => {
+            clearTimeout(stID);
+            reject(onTimeout)
+        }, miliseconds)
+    })
+
+    // Returns a race between our timeout and the passed in promise
+    return Promise.race([
+        inputPromise,
+        timeout
+    ])
+}

package/ts/index.test.ts

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

package/ts/index.ts

@@ -8,3 +8,5 @@ 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"