web-manager 3.2.45 → 3.2.47

package/index.js

@@ -1207,7 +1207,7 @@ function Manager() {
       var buildTimeCurrent = self.properties.global.buildTime;
       var buildTimeLive = new Date(data['npm-build'].timestamp);
 
-      // Set buildTimeCurrent to 1 hour ahead
+      // Set buildTimeCurrent to 1 hour ahead to account for the npm-build time which will ALWAYS be set to later since it happens later
       buildTimeCurrent.setHours(buildTimeCurrent.getHours() + 1);
 
       // Log

package/lib/account.js

@@ -267,8 +267,9 @@ Account.prototype._resolveAccount = function (firebaseUser, account, options) {
 
   // @@@DEVELOPER
   // var date = '2024-04-23T00:07:29.183Z';
-  // var date = `2024-03-23T00:07:29.183Z`;
-  // account.plan.id = 'basic';
+  // // var date = `2024-03-23T00:07:29.183Z`;
+  // // account.plan.id = 'basic';
+  // account.plan.id = 'premium';
   // account.plan.trial = {
   //   activated: false,
   //   expires: {
@@ -281,6 +282,43 @@ Account.prototype._resolveAccount = function (firebaseUser, account, options) {
   //   timestampUNIX: Math.round(new Date(date).getTime() / 1000),
   // }
   // account.plan.status = 'cancelled';
+  // account.plan = {
+  //   "id": "premium",
+  //   "payment": {
+  //     "frequency": "monthly",
+  //     "startDate": {
+  //       "timestampUNIX": 1711373195,
+  //       "timestamp": "2024-03-25T13:26:35.000Z"
+  //     },
+  //     "updatedBy": {
+  //       "date": {
+  //         "timestamp": "2024-04-02T13:46:47.441Z",
+  //         "timestampUNIX": 1712065607
+  //       },
+  //       "event": {
+  //         "name": "subscription-profile-fixer",
+  //         "id": "subscription-profile-fixer"
+  //       }
+  //     },
+  //     "resourceId": "AzyrfuU82V0cZ87qp",
+  //     "orderId": "0908-176942-1223",
+  //     "active": false,
+  //     "processor": "chargebee"
+  //   },
+  //   "trial": {
+  //     "expires": {
+  //       "timestamp": "1970-01-01T00:00:00.000Z",
+  //       "timestampUNIX": 0
+  //     },
+  //     "activated": true
+  //   },
+  //   "expires": {
+  //     "timestampUNIX": 1714656799,
+  //     "timestamp": "2024-05-02T13:33:19.000Z"
+  //   },
+  //   "limits": {},
+  //   "status": "cancelled"
+  // },
 
   account.plan.limits = account.plan.limits || {};
   // account.plan.devices = account.plan.devices || 1;
@@ -516,11 +554,21 @@ Account.prototype._resolveAccount = function (firebaseUser, account, options) {
     // Change the status to 'failed' if the plan is suspended because room temperature IQ people think 'suspended' means 'cancelled'
     var visibleStatus = uppercase(account.plan.status === 'suspended' ? 'failed payment' : account.plan.status);
     // If user is on trial, start date is trial exp date
-    var visibleStartDate = account.plan.trial.activated ? account.plan.trial.expires.timestamp : account.plan.payment.startDate.timestamp;
+    var visibleStartDate = null;
     // If basic, just show account creation date
     if (unresolvedPlanId === defaultPlanId) {
       visibleStartDate = accountCreationDate;
       billingStatusEl.setAttribute('hidden', true);
+    } else {
+      if (account.plan.status === 'cancelled') {
+        visibleStartDate = account.plan.payment.startDate.timestamp;
+      } else {
+        if (account.plan.trial.activated) {
+          visibleStartDate = account.plan.trial.expires.timestamp;
+        }
+      }
+
+      visibleStartDate = visibleStartDate || accountCreationDate;
     }
     var visibleFrequency = account.plan.payment.frequency === 'unknown' ? 'monthly' : account.plan.payment.frequency;
 

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);
+Utilities.get = function (object, path, defaultValue) {
+  // If the path is not defined or it has false value
+  if (!path) {
+    return defaultValue;
+  }
 
-  return fullPath.every(everyFunc) ? obj : def;
+  // 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('.');
 
-  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);
+  // For each item in the path, dig into the object
+  let currentObject = object;
+  for (const key of pathArray) {
+    if (!currentObject || !currentObject.hasOwnProperty(key)) {
+      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,13 @@
 {
   "name": "web-manager",
-  "version": "3.2.45",
+  "version": "3.2.47",
   "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"
@@ -35,5 +38,9 @@
     "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);
+      });
+
+    });
+
+  });
+
+})