web-manager 3.2.46 → 3.2.48

package/lib/debug.js

@@ -8,7 +8,7 @@ function Debug(utilObj) {
 Debug.promise = function(status, data, options) {
   options = options || {};
   options.wait = options.wait || {enabled: false};
-  return new Promise((resolve, reject) => {
+  return new Promise(function (resolve, reject) {
     if (status == 'resolve') {
       if (options.wait.enabled) {
         Debug.wait(options.wait.msec, options.wait.range)
@@ -48,7 +48,9 @@ Debug.wait = function(msec, range) {
   msec = msec + randomNumPlus - randomNumMinus;
   msec = (msec <= 0) ? 50 : msec;
   console.log('[DEBUG] waiting...', msec);
-  return new Promise(resolve => setTimeout(resolve, msec));
+  return new Promise(function (resolve, reject) {
+    setTimeout(resolve, msec);
+  });
 }
 
 module.exports = Debug;

package/lib/dom.js

@@ -275,7 +275,7 @@ Dom.loadScript = function(options, callback) {
 
     // Set the script attributes
     options.attributes
-    .forEach(attribute => {
+    .forEach(function (attribute) {
       s.setAttribute(attribute.name, attribute.value);
     });
 

package/lib/utilities.js

@@ -7,23 +7,26 @@ function Utilities(utilObj) {
   this.utilities = utilObj;
 }
 
-/* https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf */
-Utilities.get = function (obj, path, def) {
-  var fullPath = (path || '')
-    .replace(/\[/g, '.')
-    .replace(/]/g, '')
-    .split('.')
-    .filter(Boolean);
-
-  return fullPath.every(everyFunc) ? obj : def;
-
-  function everyFunc(step) {
-    // return !(step && (obj = obj[step]) === undefined);
-    // console.log(' CHECK > ', !(step && (obj = obj[step]) === undefined));
-    // console.log('step', step, 'obj', obj, 'objstep', obj[step]);
-    // return !(step && (obj = obj[step]) === undefined);
-    return !(step && (obj = obj[step]) === undefined);
+Utilities.get = function (object, path, defaultValue) {
+  // If the path is not defined or it has false value
+  if (!path) {
+    return defaultValue;
+  }
+
+  // Check if the path is a string or array. If it is a string, convert it to array
+  const pathArray = Array.isArray(path) ? path : path.split('.');
+
+  // For each item in the path, dig into the object
+  let currentObject = object;
+  for (const key of pathArray) {
+    if (!currentObject || currentObject[key] === undefined) {
+      return defaultValue;
+    }
+    currentObject = currentObject[key];
   }
+
+  // Return the value
+  return currentObject === undefined ? defaultValue : currentObject;
 }
 
 /* https://stackoverflow.com/questions/54733539/javascript-implementation-of-lodash-set-method */
@@ -48,6 +51,28 @@ Utilities.set = function (obj, path, value) {
   return obj; // Return the top-level object to allow chaining
 }
 
+/* https://gist.github.com/jeneg/9767afdcca45601ea44930ea03e0febf */
+// Utilities.getLegacy = function (obj, path, def) {
+//   if (!path) {
+//     return def;
+//   }
+//   var fullPath = (path || '')
+//     .replace(/\[/g, '.')
+//     .replace(/]/g, '')
+//     .split('.')
+//     .filter(Boolean);
+
+//   return fullPath.every(everyFunc) ? obj : def;
+
+//   function everyFunc(step) {
+//     // return !(step && (obj = obj[step]) === undefined);
+//     // console.log(' CHECK > ', !(step && (obj = obj[step]) === undefined));
+//     // console.log('step', step, 'obj', obj, 'objstep', obj[step]);
+//     // return !(step && (obj = obj[step]) === undefined);
+//     return !(step && (obj = obj[step]) === undefined);
+//   }
+// }
+
 // https://dzone.com/articles/cross-browser-javascript-copy-and-paste
 // https://hackernoon.com/copying-text-to-clipboard-with-javascript-df4d4988697f
 Utilities.clipboardCopy = function (input) {

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "web-manager",
-  "version": "3.2.46",
+  "version": "3.2.48",
   "description": "Easily access important variables such as the query string, current domain, and current page in a single object.",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
+    "test_": "npm run prepare && ./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
+    "prepare_": "node -e 'require(`prepare-package`)()'"
   },
   "engines": {
     "node": ">=6.0.0"
@@ -31,9 +33,13 @@
     }
   },
   "dependencies": {
-    "@sentry/browser": "^7.108.0",
+    "@sentry/browser": "^7.110.1",
     "cookieconsent": "^3.1.1",
     "firebase": "^9.23.0",
     "lazysizes": "^5.3.2"
+  },
+  "devDependencies": {
+    "lodash": "^4.17.21",
+    "mocha": "^8.4.0"
   }
 }

package/test/test.js

@@ -0,0 +1,158 @@
+const package = require('../package.json');
+const assert = require('assert');
+
+beforeEach(() => {
+});
+
+before(() => {
+});
+
+after(() => {
+});
+
+/*
+ * ============
+ *  Test Cases
+ * ============
+ */
+describe(`${package.name}`, () => {
+  const _ = require('../lib/utilities.js');
+  const lodash = require('lodash');
+
+  // Utilities
+  describe('.utilities()', () => {
+    const sample = {
+      main: {
+        true: true,
+        false: false,
+        zero: 0,
+        one: 1,
+        string: 'string',
+        stringEmpty: '',
+        object: {},
+        array: [],
+        null: null,
+        undefined: undefined,
+        nan: NaN,
+        infinity: Infinity,
+        negativeInfinity: -Infinity,
+        function: function () {},
+      }
+    }
+
+    // Normal Cases
+    describe('.get()', () => {
+      it('should return true', () => {
+        // console.log('---lodash', lodash.get(sample, 'main.true'));
+        // console.log('---_.get', _.get(sample, 'main.true'));
+        // console.log('---_.get2', _.get2(sample, 'main.true'));
+
+        assert.strictEqual(_.get(sample, 'main.true'), true);
+      });
+
+      it('should return false', () => {
+        assert.strictEqual(_.get(sample, 'main.false'), false);
+      });
+
+      it('should return 0', () => {
+        assert.strictEqual(_.get(sample, 'main.zero'), 0);
+      });
+
+      it('should return 1', () => {
+        assert.strictEqual(_.get(sample, 'main.one'), 1);
+      });
+
+      it('should return a string', () => {
+        assert.strictEqual(_.get(sample, 'main.string'), 'string');
+      });
+
+      it('should return an empty string', () => {
+        assert.strictEqual(_.get(sample, 'main.stringEmpty'), '');
+      });
+
+      it('should return an object', () => {
+        assert.deepStrictEqual(_.get(sample, 'main.object'), {});
+      });
+
+      it('should return an array', () => {
+        assert.deepStrictEqual(_.get(sample, 'main.array'), []);
+      });
+
+      it('should return null', () => {
+        assert.strictEqual(_.get(sample, 'main.null'), null);
+      });
+
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(sample, 'main.undefined'), undefined);
+      });
+
+      it('should return NaN', () => {
+        assert.strictEqual(Number.isNaN(_.get(sample, 'main.nan')), true);
+      });
+
+      it('should return Infinity', () => {
+        assert.strictEqual(_.get(sample, 'main.infinity'), Infinity);
+      });
+
+      it('should return -Infinity', () => {
+        assert.strictEqual(_.get(sample, 'main.negativeInfinity'), -Infinity);
+      });
+
+      it('should return a function', () => {
+        assert.strictEqual(typeof _.get(sample, 'main.function'), 'function');
+      });
+
+      // Non-existent
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(sample, 'main.nonexistent'), undefined);
+      });
+
+      // No path
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(sample), undefined);
+      });
+
+      // Empty path
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(sample, ''), undefined);
+      });
+
+      // Default value
+      it('should return default value', () => {
+        assert.strictEqual(_.get(sample, 'main.nonexistent', 'default'), 'default');
+      });
+
+      it('should return actual value', () => {
+        assert.strictEqual(_.get(sample, 'main.false', 'default'), false);
+      });
+
+      it('should return actual value', () => {
+        assert.strictEqual(_.get(sample, 'main.null', 'default'), null);
+      });
+
+      it('should return default value', () => {
+        assert.strictEqual(_.get(sample, 'main.undefined', 'default'), 'default');
+      });
+
+      // Non-object for object
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(undefined, 'main.true'), undefined);
+      });
+
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(null, 'main.true'), undefined);
+      });
+
+      it('should return undefined', () => {
+        assert.strictEqual(_.get(false, 'main.true'), undefined);
+      });
+
+      it('should return undefined', () => {
+        assert.strictEqual(_.get('', 'main.true'), undefined);
+      });
+
+    });
+
+  });
+
+})