mixpanel-browser 2.56.0 → 2.57.1

package/src/shared-lock.js

@@ -1,4 +1,5 @@
-import { console_with_prefix, localStorageSupported } from './utils'; // eslint-disable-line camelcase
+import { Promise } from './promise-polyfill';
+import { console_with_prefix, localStorageSupported, _ } from './utils'; // eslint-disable-line camelcase
 
 var logger = console_with_prefix('lock');
 
@@ -29,121 +30,126 @@ var SharedLock = function(key, options) {
     this.storage = options.storage || window.localStorage;
     this.pollIntervalMS = options.pollIntervalMS || 100;
     this.timeoutMS = options.timeoutMS || 2000;
+
+    // dependency-inject promise implementation for testing purposes
+    this.promiseImpl = options.promiseImpl || Promise;
 };
 
 // pass in a specific pid to test contention scenarios; otherwise
 // it is chosen randomly for each acquisition attempt
-SharedLock.prototype.withLock = function(lockedCB, errorCB, pid) {
-    if (!pid && typeof errorCB !== 'function') {
-        pid = errorCB;
-        errorCB = null;
-    }
-
-    var i = pid || (new Date().getTime() + '|' + Math.random());
-    var startTime = new Date().getTime();
-
-    var key = this.storageKey;
-    var pollIntervalMS = this.pollIntervalMS;
-    var timeoutMS = this.timeoutMS;
-    var storage = this.storage;
-
-    var keyX = key + ':X';
-    var keyY = key + ':Y';
-    var keyZ = key + ':Z';
-
-    var reportError = function(err) {
-        errorCB && errorCB(err);
-    };
-
-    var delay = function(cb) {
-        if (new Date().getTime() - startTime > timeoutMS) {
-            logger.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
-            storage.removeItem(keyZ);
-            storage.removeItem(keyY);
-            loop();
-            return;
-        }
-        setTimeout(function() {
-            try {
+SharedLock.prototype.withLock = function(lockedCB, pid) {
+    var Promise = this.promiseImpl;
+    return new Promise(_.bind(function (resolve, reject) {
+        var i = pid || (new Date().getTime() + '|' + Math.random());
+        var startTime = new Date().getTime();
+
+        var key = this.storageKey;
+        var pollIntervalMS = this.pollIntervalMS;
+        var timeoutMS = this.timeoutMS;
+        var storage = this.storage;
+
+        var keyX = key + ':X';
+        var keyY = key + ':Y';
+        var keyZ = key + ':Z';
+
+        var delay = function(cb) {
+            if (new Date().getTime() - startTime > timeoutMS) {
+                logger.error('Timeout waiting for mutex on ' + key + '; clearing lock. [' + i + ']');
+                storage.removeItem(keyZ);
+                storage.removeItem(keyY);
+                loop();
+                return;
+            }
+            setTimeout(function() {
+                try {
+                    cb();
+                } catch(err) {
+                    reject(err);
+                }
+            }, pollIntervalMS * (Math.random() + 0.1));
+        };
+
+        var waitFor = function(predicate, cb) {
+            if (predicate()) {
                 cb();
-            } catch(err) {
-                reportError(err);
+            } else {
+                delay(function() {
+                    waitFor(predicate, cb);
+                });
             }
-        }, pollIntervalMS * (Math.random() + 0.1));
-    };
-
-    var waitFor = function(predicate, cb) {
-        if (predicate()) {
-            cb();
-        } else {
-            delay(function() {
-                waitFor(predicate, cb);
-            });
-        }
-    };
-
-    var getSetY = function() {
-        var valY = storage.getItem(keyY);
-        if (valY && valY !== i) { // if Y == i then this process already has the lock (useful for test cases)
-            return false;
-        } else {
-            storage.setItem(keyY, i);
-            if (storage.getItem(keyY) === i) {
-                return true;
+        };
+
+        var getSetY = function() {
+            var valY = storage.getItem(keyY);
+            if (valY && valY !== i) { // if Y == i then this process already has the lock (useful for test cases)
+                return false;
             } else {
-                if (!localStorageSupported(storage, true)) {
-                    throw new Error('localStorage support dropped while acquiring lock');
+                storage.setItem(keyY, i);
+                if (storage.getItem(keyY) === i) {
+                    return true;
+                } else {
+                    if (!localStorageSupported(storage, true)) {
+                        reject(new Error('localStorage support dropped while acquiring lock'));
+                    }
+                    return false;
                 }
-                return false;
             }
-        }
-    };
-
-    var loop = function() {
-        storage.setItem(keyX, i);
+        };
 
-        waitFor(getSetY, function() {
-            if (storage.getItem(keyX) === i) {
-                criticalSection();
-                return;
-            }
+        var loop = function() {
+            storage.setItem(keyX, i);
 
-            delay(function() {
-                if (storage.getItem(keyY) !== i) {
-                    loop();
+            waitFor(getSetY, function() {
+                if (storage.getItem(keyX) === i) {
+                    criticalSection();
                     return;
                 }
-                waitFor(function() {
-                    return !storage.getItem(keyZ);
-                }, criticalSection);
+
+                delay(function() {
+                    if (storage.getItem(keyY) !== i) {
+                        loop();
+                        return;
+                    }
+                    waitFor(function() {
+                        return !storage.getItem(keyZ);
+                    }, criticalSection);
+                });
             });
-        });
-    };
+        };
+
+        var criticalSection = function() {
+            storage.setItem(keyZ, '1');
+            var removeLock = function () {
+                storage.removeItem(keyZ);
+                if (storage.getItem(keyY) === i) {
+                    storage.removeItem(keyY);
+                }
+                if (storage.getItem(keyX) === i) {
+                    storage.removeItem(keyX);
+                }
+            };
+
+            lockedCB()
+                .then(function (ret) {
+                    removeLock();
+                    resolve(ret);
+                })
+                .catch(function (err) {
+                    removeLock();
+                    reject(err);
+                });
+        };
 
-    var criticalSection = function() {
-        storage.setItem(keyZ, '1');
         try {
-            lockedCB();
-        } finally {
-            storage.removeItem(keyZ);
-            if (storage.getItem(keyY) === i) {
-                storage.removeItem(keyY);
-            }
-            if (storage.getItem(keyX) === i) {
-                storage.removeItem(keyX);
+            if (localStorageSupported(storage, true)) {
+                loop();
+            } else {
+                throw new Error('localStorage support check failed');
             }
+        } catch(err) {
+            reject(err);
         }
-    };
-
-    try {
-        if (localStorageSupported(storage, true)) {
-            loop();
-        } else {
-            throw new Error('localStorage support check failed');
-        }
-    } catch(err) {
-        reportError(err);
-    }
+    }, this));
 };
 
 export { SharedLock };

package/src/storage/local-storage.js

@@ -0,0 +1,53 @@
+import { Promise } from '../promise-polyfill';
+import { _ } from '../utils'; // eslint-disable-line camelcase
+
+/**
+ * @typedef {import('./wrapper').StorageWrapper}
+ */
+
+/**
+ * @type {StorageWrapper}
+ */
+var LocalStorageWrapper = function (storageOverride) {
+    this.storage = storageOverride || localStorage;
+};
+
+LocalStorageWrapper.prototype.init = function () {
+    return Promise.resolve();
+};
+
+LocalStorageWrapper.prototype.setItem = function (key, value) {
+    return new Promise(_.bind(function (resolve, reject) {
+        try {
+            this.storage.setItem(key, value);
+        } catch (e) {
+            reject(e);
+        }
+        resolve();
+    }, this));
+};
+
+LocalStorageWrapper.prototype.getItem = function (key) {
+    return new Promise(_.bind(function (resolve, reject) {
+        var item;
+        try {
+            item = this.storage.getItem(key);
+        } catch (e) {
+            reject(e);
+        }
+        resolve(item);
+    }, this));
+};
+
+LocalStorageWrapper.prototype.removeItem = function (key) {
+    return new Promise(_.bind(function (resolve, reject) {
+        try {
+            this.storage.removeItem(key);
+        } catch (e) {
+            reject(e);
+        }
+        resolve();
+    }, this));
+};
+
+export { LocalStorageWrapper };

package/src/storage/wrapper.js

@@ -0,0 +1,14 @@
+/**
+ * Storage abstraction layer to support sync/async browser storage mechanisms.
+ * This file only exists for the jsdoc type definition.
+ */
+
+/**
+ * @typedef {Object} StorageWrapper
+ * @property {function():Promise<void>} init - Initializes the wrapper, async storage like IDB needs to create a table and upgrade if needed.
+ * @property {function(string, string):Promise<void>} setItem - Sets an item in storage.
+ * @property {function(string):Promise<string>} getItem - Retrieves an item from storage.
+ * @property {function(string, string):Promise<void>} removeItem - Removes an item from storage.
+ */
+
+export { };

package/src/utils.js

@@ -1,24 +1,7 @@
 /* eslint camelcase: "off", eqeqeq: "off" */
 import Config from './config';
-
-// since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
-var win;
-if (typeof(window) === 'undefined') {
-    var loc = {
-        hostname: ''
-    };
-    win = {
-        navigator: { userAgent: '', onLine: true },
-        document: {
-            location: loc,
-            referrer: ''
-        },
-        screen: { width: 0, height: 0 },
-        location: loc
-    };
-} else {
-    win = window;
-}
+import { NpoPromise } from './promise-polyfill';
+import { window } from './window';
 
 // Maximum allowed session recording length
 var MAX_RECORDING_MS = 24 * 60 * 60 * 1000; // 24 hours
@@ -36,11 +19,11 @@ var ArrayProto = Array.prototype,
     slice = ArrayProto.slice,
     toString = ObjProto.toString,
     hasOwnProperty = ObjProto.hasOwnProperty,
-    windowConsole = win.console,
-    navigator = win.navigator,
-    document = win.document,
-    windowOpera = win.opera,
-    screen = win.screen,
+    windowConsole = window.console,
+    navigator = window.navigator,
+    document = window.document,
+    windowOpera = window.opera,
+    screen = window.screen,
     userAgent = navigator.userAgent;
 
 var nativeBind = FuncProto.bind,
@@ -839,8 +822,8 @@ _.UUID = (function() {
     var T = function() {
         var time = 1 * new Date(); // cross-browser version of Date.now()
         var ticks;
-        if (win.performance && win.performance.now) {
-            ticks = win.performance.now();
+        if (window.performance && window.performance.now) {
+            ticks = window.performance.now();
         } else {
             // fall back to busy loop
             ticks = 0;
@@ -1626,7 +1609,7 @@ _.info = {
     },
 
     currentUrl: function() {
-        return win.location.href;
+        return window.location.href;
     },
 
     properties: function(extra_props) {
@@ -1663,10 +1646,10 @@ _.info = {
     mpPageViewProperties: function() {
         return _.strip_empty_properties({
             'current_page_title': document.title,
-            'current_domain': win.location.hostname,
-            'current_url_path': win.location.pathname,
-            'current_url_protocol': win.location.protocol,
-            'current_url_search': win.location.search
+            'current_domain': window.location.hostname,
+            'current_url_path': window.location.pathname,
+            'current_url_protocol': window.location.protocol,
+            'current_url_search': window.location.search
         });
     }
 };
@@ -1709,7 +1692,7 @@ var extract_domain = function(hostname) {
  * @returns {boolean}
  */
 var isOnline = function() {
-    var onLine = win.navigator['onLine'];
+    var onLine = window.navigator['onLine'];
     return _.isUndefined(onLine) || onLine;
 };
 
@@ -1733,6 +1716,7 @@ _['info']['device']         = _.info.device;
 _['info']['browser']        = _.info.browser;
 _['info']['browserVersion'] = _.info.browserVersion;
 _['info']['properties']     = _.info.properties;
+_['NPO']                    = NpoPromise;
 
 export {
     _,
@@ -1750,5 +1734,4 @@ export {
     navigator,
     slice,
     userAgent,
-    win as window
 };

package/src/window.js

@@ -0,0 +1,20 @@
+// since es6 imports are static and we run unit tests from the console, window won't be defined when importing this file
+var win;
+if (typeof(window) === 'undefined') {
+    var loc = {
+        hostname: ''
+    };
+    win = {
+        navigator: { userAgent: '', onLine: true },
+        document: {
+            location: loc,
+            referrer: ''
+        },
+        screen: { width: 0, height: 0 },
+        location: loc
+    };
+} else {
+    win = window;
+}
+
+export { win as window };