@ninetailed/experience.js 1.5.0 → 1.5.1

package/index.d.ts

@@ -2,4 +2,4 @@ export * from './lib/analytics';
 export * from './lib/Ninetailed';
 export * from './lib/selectVariant';
 export * from './lib/types';
-export { Profile } from '@ninetailed/experience.js-shared';
+export type { Profile } from '@ninetailed/experience.js-shared';

package/index.esm.js

@@ -1,5 +1,4 @@
 import get$2 from 'lodash/get';
-import throttle from 'lodash/throttle';
 import unionBy from 'lodash/unionBy';
 import { buildEmptyCache, buildTrackEvent, buildIdentifyEvent, buildPageEvent } from '@ninetailed/experience.js-shared';
 import require$$1 from 'tty';
@@ -3439,7 +3438,37 @@ const NINETAILED_TRACKER_EVENTS = {
 const PLUGIN_NAME = 'ninetailed';
 
 const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+/**
+ * Similar to _.throttle but waits for the promise to resolve. There is no
+ * wait time because you can simply await `Promise.timeout` inside `fn`
+ * to wait some time before the next call.
+ */
+
+
+function asyncThrottle(fn) {
+  let runningPromise;
+  let queuedPromise;
+  let nextArgs;
+  return args => __awaiter(this, void 0, void 0, function* () {
+    if (runningPromise) {
+      nextArgs = args;
 
+      if (queuedPromise) {
+        return queuedPromise;
+      } else {
+        queuedPromise = runningPromise.then(() => {
+          queuedPromise = undefined;
+          runningPromise = fn(nextArgs);
+          return runningPromise;
+        });
+        return queuedPromise;
+      }
+    } else {
+      runningPromise = fn(args);
+      return runningPromise;
+    }
+  });
+}
 const ninetailedPlugin = ({
   clientId,
   environment,
@@ -3448,7 +3477,6 @@ const ninetailedPlugin = ({
   profile,
   locale
 }) => {
-  let isFirstEvent = true;
   let isInitialized = false;
   const apiClient = new NinetailedApiClient({
     clientId,
@@ -3523,23 +3551,21 @@ const ninetailedPlugin = ({
         },
         cache
       });
-    }
-  });
+    } // This is necessary to make sure that the cache is updated before the next flush is performed
+
+
+    yield delay(20);
+  }); // const throttledFlush = throttle(flush, 200, {
+  //   leading: false,
+  //   trailing: true,
+  // });
 
-  const throttledFlush = throttle(flush, 200, {
-    leading: false,
-    trailing: true
-  });
+
+  const throttledFlush = asyncThrottle(flush);
 
   const createEvent = (event, instance) => __awaiter(void 0, void 0, void 0, function* () {
     queue = unionBy([event], queue, 'messageId');
-
-    if (isFirstEvent) {
-      flush(instance);
-      isFirstEvent = false;
-    } else {
-      throttledFlush(instance);
-    }
+    throttledFlush(instance);
   });
 
   return {

package/index.umd.js

@@ -1,13 +1,12 @@
 (function (global, factory) {
-	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/get'), require('lodash/throttle'), require('lodash/unionBy'), require('@ninetailed/experience.js-shared'), require('tty'), require('util'), require('os'), require('analytics'), require('lodash/flatten'), require('lodash/find'), require('lodash/includes')) :
-	typeof define === 'function' && define.amd ? define(['exports', 'lodash/get', 'lodash/throttle', 'lodash/unionBy', '@ninetailed/experience.js-shared', 'tty', 'util', 'os', 'analytics', 'lodash/flatten', 'lodash/find', 'lodash/includes'], factory) :
-	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Javascript = {}, global.get$2, global.throttle, global.unionBy, global.experience_jsShared, global.require$$1, global.require$$1$1, global.require$$0, global.Analytics, global.flatten, global.find, global.includes));
-})(this, (function (exports, get$2, throttle, unionBy, experience_jsShared, require$$1, require$$1$1, require$$0, Analytics, flatten, find, includes) { 'use strict';
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('lodash/get'), require('lodash/unionBy'), require('@ninetailed/experience.js-shared'), require('tty'), require('util'), require('os'), require('analytics'), require('lodash/flatten'), require('lodash/find'), require('lodash/includes')) :
+	typeof define === 'function' && define.amd ? define(['exports', 'lodash/get', 'lodash/unionBy', '@ninetailed/experience.js-shared', 'tty', 'util', 'os', 'analytics', 'lodash/flatten', 'lodash/find', 'lodash/includes'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Javascript = {}, global.get$2, global.unionBy, global.experience_jsShared, global.require$$1, global.require$$1$1, global.require$$0, global.Analytics, global.flatten, global.find, global.includes));
+})(this, (function (exports, get$2, unionBy, experience_jsShared, require$$1, require$$1$1, require$$0, Analytics, flatten, find, includes) { 'use strict';
 
 	function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 	var get__default = /*#__PURE__*/_interopDefaultLegacy(get$2);
-	var throttle__default = /*#__PURE__*/_interopDefaultLegacy(throttle);
 	var unionBy__default = /*#__PURE__*/_interopDefaultLegacy(unionBy);
 	var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 	var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
@@ -3545,7 +3544,49 @@
 	    return setTimeout(resolve, ms);
 	  });
 	};
+	/**
+	 * Similar to _.throttle but waits for the promise to resolve. There is no
+	 * wait time because you can simply await `Promise.timeout` inside `fn`
+	 * to wait some time before the next call.
+	 */
+
+
+	function asyncThrottle(fn) {
+	  var _this = this;
+
+	  var runningPromise;
+	  var queuedPromise;
+	  var nextArgs;
+	  return function (args) {
+	    return __awaiter(_this, void 0, void 0, function () {
+	      return __generator(this, function (_a) {
+	        if (runningPromise) {
+	          nextArgs = args;
 
+	          if (queuedPromise) {
+	            return [2
+	            /*return*/
+	            , queuedPromise];
+	          } else {
+	            queuedPromise = runningPromise.then(function () {
+	              queuedPromise = undefined;
+	              runningPromise = fn(nextArgs);
+	              return runningPromise;
+	            });
+	            return [2
+	            /*return*/
+	            , queuedPromise];
+	          }
+	        } else {
+	          runningPromise = fn(args);
+	          return [2
+	          /*return*/
+	          , runningPromise];
+	        }
+	      });
+	    });
+	  };
+	}
 	var ninetailedPlugin = function ninetailedPlugin(_a) {
 	  var clientId = _a.clientId,
 	      environment = _a.environment,
@@ -3554,7 +3595,6 @@
 	      url = _a.url,
 	      profile = _a.profile,
 	      locale = _a.locale;
-	  var isFirstEvent = true;
 	  var isInitialized = false;
 	  var apiClient = new NinetailedApiClient({
 	    clientId: clientId,
@@ -3650,31 +3690,34 @@
 	            , 4];
 
 	          case 4:
+	            // This is necessary to make sure that the cache is updated before the next flush is performed
+	            return [4
+	            /*yield*/
+	            , delay(20)];
+
+	          case 5:
+	            // This is necessary to make sure that the cache is updated before the next flush is performed
+	            _b.sent();
+
 	            return [2
 	            /*return*/
 	            ];
 	        }
 	      });
 	    });
-	  };
+	  }; // const throttledFlush = throttle(flush, 200, {
+	  //   leading: false,
+	  //   trailing: true,
+	  // });
 
-	  var throttledFlush = throttle__default["default"](flush, 200, {
-	    leading: false,
-	    trailing: true
-	  });
+
+	  var throttledFlush = asyncThrottle(flush);
 
 	  var createEvent = function createEvent(event, instance) {
 	    return __awaiter(void 0, void 0, void 0, function () {
 	      return __generator(this, function (_a) {
 	        queue = unionBy__default["default"]([event], queue, 'messageId');
-
-	        if (isFirstEvent) {
-	          flush(instance);
-	          isFirstEvent = false;
-	        } else {
-	          throttledFlush(instance);
-	        }
-
+	        throttledFlush(instance);
 	        return [2
 	        /*return*/
 	        ];

package/lib/analytics/get-analytics-plugin.d.ts

@@ -21,5 +21,11 @@ export declare const NINETAILED_TRACKER_EVENTS: {
     profile: string;
 };
 export declare const PLUGIN_NAME = "ninetailed";
+/**
+ * Similar to _.throttle but waits for the promise to resolve. There is no
+ * wait time because you can simply await `Promise.timeout` inside `fn`
+ * to wait some time before the next call.
+ */
+export default function asyncThrottle<I, O = void>(fn: (args: I) => Promise<O>): (args: I) => Promise<O>;
 export declare const ninetailedPlugin: ({ clientId, environment, preview, url, profile, locale, }: AnalyticsPluginNinetailedConfig) => AnalyticsPlugin;
 export {};

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@ninetailed/experience.js",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "main": "./index.umd.js",
   "module": "./index.esm.js",
   "typings": "./index.d.ts",
   "dependencies": {
-    "@ninetailed/experience.js-shared": "1.5.0",
+    "analytics": "^0.8.0",
+    "@ninetailed/experience.js-shared": "1.5.1",
     "uuid": "^8.3.2",
     "ts-toolbelt": "^9.6.0",
     "locale-enum": "^1.1.1",
     "i18n-iso-countries": "^7.3.0",
-    "analytics": "^0.8.0",
     "lodash": "^4.17.21"
   },
   "peerDependencies": {}