@kameleoon/javascript-sdk-core 1.1.1 → 2.1.0

package/dist/cacheManager/cacheManager.d.ts

@@ -0,0 +1,38 @@
+import { AddParametersType } from './types';
+interface ICacheManager<T> {
+    /**
+     * Add item to cache
+     * @param {AddParametersType<T>} parameters - parameters for adding new item cache
+     * @returns {void}
+     */
+    add({ key, data, lifetime }: AddParametersType<T>): void;
+    /**
+     * Get item that is not expired from cache
+     * @param {string} key - key of item
+     * @returns {T} an item that is not expired
+     */
+    getAliveItem(key: string): T | null;
+}
+/**
+ * @class
+ * CacheManager - a class for managing cache
+ */
+export declare class CacheManager<T> implements ICacheManager<T> {
+    private cacheMap;
+    private intervalId;
+    private cleanupTimeout;
+    /**
+     * @param {number} cleanupTimeout - timeout for cleaning cache in seconds
+     * generic type `T` is a type of data that will be stored in cache
+     * @example
+     * ```typescript
+     * const cacheManager = new CacheManager<number>(60);
+     * ```
+     */
+    constructor(cleanupTimeout: number);
+    add({ key, data, lifetime }: AddParametersType<T>): void;
+    getAliveItem(key: string): T | null;
+    private activate;
+    private cleanupInterval;
+}
+export {};

package/dist/cacheManager/cacheManager.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CacheManager = void 0;
+var _types = require("../types");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * @class
+ * CacheManager - a class for managing cache
+ */
+class CacheManager {
+  /**
+   * @param {number} cleanupTimeout - timeout for cleaning cache in seconds
+   * generic type `T` is a type of data that will be stored in cache
+   * @example
+   * ```typescript
+   * const cacheManager = new CacheManager<number>(60);
+   * ```
+   */
+  constructor(cleanupTimeout) {
+    _defineProperty(this, "cacheMap", new Map());
+    _defineProperty(this, "intervalId", null);
+    _defineProperty(this, "cleanupTimeout", void 0);
+    this.cleanupTimeout = cleanupTimeout * _types.Milliseconds.Second;
+  }
+  add({
+    key,
+    data,
+    lifetime
+  }) {
+    if (this.intervalId === null) {
+      this.activate();
+    }
+    const expirationTime = lifetime * _types.Milliseconds.Second;
+    const cacheItem = {
+      data,
+      expirationTime: Date.now() + expirationTime
+    };
+    this.cacheMap.set(key, cacheItem);
+  }
+  getAliveItem(key) {
+    const cacheItem = this.cacheMap.get(key);
+    if (cacheItem && cacheItem.expirationTime >= Date.now()) {
+      return cacheItem.data;
+    }
+    cacheItem && this.cacheMap.delete(key);
+    return null;
+  }
+  activate() {
+    this.intervalId = setInterval(() => {
+      const now = Date.now();
+      for (const [key, item] of this.cacheMap) {
+        if (item.expirationTime < now) {
+          this.cacheMap.delete(key);
+        }
+      }
+      if (!this.cacheMap.size) {
+        this.cleanupInterval();
+      }
+    }, this.cleanupTimeout);
+  }
+  cleanupInterval() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+}
+exports.CacheManager = CacheManager;
+//# sourceMappingURL=cacheManager.js.map

package/dist/cacheManager/cacheManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheManager.js","names":["_types","require","_defineProperty","obj","key","value","_toPropertyKey","Object","defineProperty","enumerable","configurable","writable","arg","_toPrimitive","String","input","hint","prim","Symbol","toPrimitive","undefined","res","call","TypeError","Number","CacheManager","constructor","cleanupTimeout","Map","Milliseconds","Second","add","data","lifetime","intervalId","activate","expirationTime","cacheItem","Date","now","cacheMap","set","getAliveItem","get","delete","setInterval","item","size","cleanupInterval","clearInterval","exports"],"sources":["../../src/cacheManager/cacheManager.ts"],"sourcesContent":["import { AddParametersType, CacheItemType } from './types';\nimport { Milliseconds } from '../types';\n\ninterface ICacheManager<T> {\n  /**\n   * Add item to cache\n   * @param {AddParametersType<T>} parameters - parameters for adding new item cache\n   * @returns {void}\n   */\n  add({ key, data, lifetime }: AddParametersType<T>): void;\n  /**\n   * Get item that is not expired from cache\n   * @param {string} key - key of item\n   * @returns {T} an item that is not expired\n   */\n  getAliveItem(key: string): T | null;\n}\n\n/**\n * @class\n * CacheManager - a class for managing cache\n */\nexport class CacheManager<T> implements ICacheManager<T> {\n  private cacheMap = new Map<string, CacheItemType<T>>();\n  private intervalId: NodeJS.Timeout | null = null;\n  private cleanupTimeout: number;\n\n  /**\n   * @param {number} cleanupTimeout - timeout for cleaning cache in seconds\n   * generic type `T` is a type of data that will be stored in cache\n   * @example\n   * ```typescript\n   * const cacheManager = new CacheManager<number>(60);\n   * ```\n   */\n  constructor(cleanupTimeout: number) {\n    this.cleanupTimeout = cleanupTimeout * Milliseconds.Second;\n  }\n\n  public add({ key, data, lifetime }: AddParametersType<T>): void {\n    if (this.intervalId === null) {\n      this.activate();\n    }\n\n    const expirationTime = lifetime * Milliseconds.Second;\n\n    const cacheItem: CacheItemType<T> = {\n      data,\n      expirationTime: Date.now() + expirationTime,\n    };\n\n    this.cacheMap.set(key, cacheItem);\n  }\n\n  public getAliveItem(key: string): T | null {\n    const cacheItem = this.cacheMap.get(key);\n\n    if (cacheItem && cacheItem.expirationTime >= Date.now()) {\n      return cacheItem.data;\n    }\n\n    cacheItem && this.cacheMap.delete(key);\n\n    return null;\n  }\n\n  private activate(): void {\n    this.intervalId = setInterval(() => {\n      const now = Date.now();\n\n      for (const [key, item] of this.cacheMap) {\n        if (item.expirationTime < now) {\n          this.cacheMap.delete(key);\n        }\n      }\n\n      if (!this.cacheMap.size) {\n        this.cleanupInterval();\n      }\n    }, this.cleanupTimeout);\n  }\n\n  private cleanupInterval(): void {\n    if (this.intervalId) {\n      clearInterval(this.intervalId);\n      this.intervalId = null;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/cacheManager/index.d.ts

@@ -0,0 +1,2 @@
+export { CacheManager } from './cacheManager';
+export { AddParametersType } from './types';

package/dist/cacheManager/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AddParametersType", {
+  enumerable: true,
+  get: function () {
+    return _types.AddParametersType;
+  }
+});
+Object.defineProperty(exports, "CacheManager", {
+  enumerable: true,
+  get: function () {
+    return _cacheManager.CacheManager;
+  }
+});
+var _cacheManager = require("./cacheManager");
+var _types = require("./types");
+//# sourceMappingURL=index.js.map

package/dist/cacheManager/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["_cacheManager","require","_types"],"sources":["../../src/cacheManager/index.ts"],"sourcesContent":["export { CacheManager } from './cacheManager';\nexport { AddParametersType } from './types';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,aAAA,GAAAC,OAAA;AACA,IAAAC,MAAA,GAAAD,OAAA"}

package/dist/cacheManager/types.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {string} key - key for adding new item cache, key must be unique otherwise the item will be overwritten
+ * @param {T} data - data for adding new item cache
+ * @param {number} lifetime - lifetime for adding new item cache in seconds
+ */
+export type AddParametersType<T> = {
+    key: string;
+    data: T;
+    lifetime: number;
+};
+export type CacheItemType<T> = {
+    data: T;
+    expirationTime: number;
+};

package/dist/cacheManager/types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=types.js.map

package/dist/cacheManager/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/cacheManager/types.ts"],"sourcesContent":["/**\n * @param {string} key - key for adding new item cache, key must be unique otherwise the item will be overwritten\n * @param {T} data - data for adding new item cache\n * @param {number} lifetime - lifetime for adding new item cache in seconds\n */\nexport type AddParametersType<T> = {\n  key: string;\n  data: T;\n  lifetime: number;\n};\n\nexport type CacheItemType<T> = {\n  data: T;\n  expirationTime: number;\n};\n"],"mappings":""}

package/dist/campaignConfiguration/campaignConfiguration.d.ts

@@ -27,7 +27,8 @@ export declare class CampaignConfiguration implements ICampaignConfiguration {
     private storage;
     private requester;
     private eventSource?;
-    constructor({ settings, storage, requester, }: CampaignConfigurationParametersType);
+    private externalClientConfiguration?;
+    constructor({ settings, storage, requester, externalClientConfiguration, targetingCleanupInterval, }: CampaignConfigurationParametersType);
     initialize(externalEventSource: IExternalEventSourceConstructor): Promise<Result<void, KameleoonError>>;
     addTargetingData(visitorCode: string, ...data: KameleoonDataType[]): Result<void, KameleoonError>;
     getUnsentData(visitorCode: string): KameleoonDataType[];

package/dist/campaignConfiguration/campaignConfiguration.js

@@ -1,217 +1,264 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 exports.CampaignConfiguration = void 0;
-const ts_res_1 = require("ts-res");
-const constants_1 = require("./constants");
-const eventSource_1 = require("../eventSource");
+var _tsRes = require("ts-res");
+var _constants = require("./constants");
+var _eventSource = require("../eventSource");
+var _types = require("../types");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
 class CampaignConfiguration {
-    constructor({ settings, storage, requester, }) {
-        this.updateConfigurationIntervalId = null;
-        this.targetingDataIntervalId = null;
-        this.unsentTargetingData = {};
-        this.targetingData = constants_1.DEFAULT_CAMPAIGN_CONFIGURATION.targetingData;
-        this.configurationData = constants_1.DEFAULT_CAMPAIGN_CONFIGURATION.configurationData;
-        this.requester = requester;
-        this.settings = settings;
-        this.lastUpdate = new Date();
-        this.storage = storage;
-        this.readStorageData();
-        // --- Note ---
-        // We can not make delayed code execution recoverable, as it might lead
-        // to targeting data storage size overflow
-        try {
-            this.targetingDataIntervalId = setInterval(() => this.cleanupOutdatedTargetingData.call(this, this.targetingData), constants_1.CLEANUP_TARGETING_DATA_INTERVAL);
-        }
-        catch (err) {
-            if (this.targetingDataIntervalId) {
-                clearInterval(this.targetingDataIntervalId);
-            }
-            throw err;
+  constructor({
+    settings,
+    storage,
+    requester,
+    externalClientConfiguration,
+    targetingCleanupInterval
+  }) {
+    _defineProperty(this, "configurationUpdateCallback", void 0);
+    _defineProperty(this, "updateConfigurationIntervalId", null);
+    _defineProperty(this, "targetingDataIntervalId", null);
+    _defineProperty(this, "unsentTargetingData", {});
+    _defineProperty(this, "targetingData", _constants.DEFAULT_CAMPAIGN_CONFIGURATION.targetingData);
+    _defineProperty(this, "configurationData", _constants.DEFAULT_CAMPAIGN_CONFIGURATION.configurationData);
+    _defineProperty(this, "settings", void 0);
+    _defineProperty(this, "lastUpdate", void 0);
+    _defineProperty(this, "storage", void 0);
+    _defineProperty(this, "requester", void 0);
+    _defineProperty(this, "eventSource", void 0);
+    _defineProperty(this, "externalClientConfiguration", void 0);
+    this.requester = requester;
+    this.settings = settings;
+    this.lastUpdate = new Date();
+    this.storage = storage;
+    this.readStorageData();
+    this.externalClientConfiguration = externalClientConfiguration;
+    if (targetingCleanupInterval) {
+      const cleanupIntervalMinutes = targetingCleanupInterval < 0 ? 1 : targetingCleanupInterval;
+
+      // --- Note ---
+      // We can not make delayed code execution recoverable, as it might lead
+      // to targeting data storage size overflow
+      try {
+        this.targetingDataIntervalId = setInterval(() => this.cleanupOutdatedTargetingData.call(this, this.targetingData), cleanupIntervalMinutes * _types.Milliseconds.Minute);
+      } catch (err) {
+        if (this.targetingDataIntervalId) {
+          clearInterval(this.targetingDataIntervalId);
         }
+        throw err;
+      }
     }
-    initialize(externalEventSource) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const shouldUpdate = this.checkShouldUpdate();
-            // --- Initial data fetch ---
-            if (shouldUpdate) {
-                const updateResult = yield this.updateClientConfiguration();
-                if (!updateResult.ok) {
-                    return updateResult;
-                }
-            }
-            // --- Note ---
-            // Interval is cleaned up in case real time update
-            // was activated while initialized client already exists
-            if (this.configurationData.configuration.realTimeUpdate) {
-                if (this.updateConfigurationIntervalId) {
-                    clearInterval(this.updateConfigurationIntervalId);
-                }
-                this.eventSource = new eventSource_1.ExternalEventSource(this.settings.siteCode, externalEventSource);
-                const updateEventCallback = (_timeStamp) => {
-                    this.updateClientConfiguration();
-                    if (this.configurationUpdateCallback) {
-                        this.configurationUpdateCallback();
-                    }
-                };
-                this.eventSource.open(updateEventCallback);
-            }
-            else {
-                // --- Note ---
-                // Event Source is cleaned up in case real time update
-                // was disabled while initialized client already exists
-                if (this.eventSource) {
-                    this.eventSource.close();
-                }
-                if (this.updateConfigurationIntervalId) {
-                    clearInterval(this.updateConfigurationIntervalId);
-                }
-                // --- Note ---
-                // Same as targeting data interval we don't want to make failed configuration
-                // retrieval recoverable
-                try {
-                    this.updateConfigurationIntervalId = setInterval(this.updateClientConfiguration.bind(this), this.settings.updateInterval);
-                }
-                catch (err) {
-                    if (this.updateConfigurationIntervalId) {
-                        clearInterval(this.updateConfigurationIntervalId);
-                    }
-                    throw err;
-                }
-            }
-            return (0, ts_res_1.Ok)();
-        });
+  }
+  async initialize(externalEventSource) {
+    const shouldUpdate = this.checkShouldUpdate();
+
+    // --- Initial data fetch ---
+    if (shouldUpdate) {
+      const updateResult = await this.updateClientConfiguration();
+      if (!updateResult.ok) {
+        return updateResult;
+      }
     }
-    addTargetingData(visitorCode, ...data) {
-        if (!(visitorCode in this.targetingData)) {
-            this.targetingData[visitorCode] = [];
-        }
-        data.forEach((dataItem) => {
-            // --- Note ---
-            // Previous check excludes the failure possibility
-            this.targetingData[visitorCode].push({
-                data: dataItem.data,
-                lastActivityTime: Date.now(),
-            });
-        });
-        // --- Note ---
-        // `targetingData` should not refresh `lastUpdate` time
-        const result = this.updateStorageData(this.lastUpdate);
-        if (result.ok) {
-            data.forEach((dataItem) => {
-                if (!this.unsentTargetingData[visitorCode]) {
-                    this.unsentTargetingData[visitorCode] = [];
-                }
-                this.unsentTargetingData[visitorCode].push(dataItem);
-            });
+
+    // --- Note ---
+    // Interval is cleaned up in case real time update
+    // was activated while initialized client already exists
+    if (this.configurationData.configuration.realTimeUpdate && !this.externalClientConfiguration) {
+      if (this.updateConfigurationIntervalId) {
+        clearInterval(this.updateConfigurationIntervalId);
+      }
+      this.eventSource = new _eventSource.ExternalEventSource(this.settings.siteCode, externalEventSource);
+      const updateEventCallback = _timeStamp => {
+        this.updateClientConfiguration();
+        if (this.configurationUpdateCallback) {
+          this.configurationUpdateCallback();
         }
-        return result;
-    }
-    getUnsentData(visitorCode) {
-        const unsentDataItem = this.unsentTargetingData[visitorCode];
-        if (!unsentDataItem) {
-            return [];
+      };
+      this.eventSource.open(updateEventCallback);
+    } else {
+      // --- Note ---
+      // Event Source is cleaned up in case real time update
+      // was disabled while initialized client already exists
+      if (this.eventSource) {
+        this.eventSource.close();
+      }
+      if (this.updateConfigurationIntervalId) {
+        clearInterval(this.updateConfigurationIntervalId);
+      }
+
+      // --- Note ---
+      // Same as targeting data interval we don't want to make failed configuration
+      // retrieval recoverable
+      try {
+        this.updateConfigurationIntervalId = setInterval(this.updateClientConfiguration.bind(this), this.settings.updateInterval);
+      } catch (err) {
+        if (this.updateConfigurationIntervalId) {
+          clearInterval(this.updateConfigurationIntervalId);
         }
-        return unsentDataItem;
-    }
-    clearUnsentData(visitorCode) {
-        this.unsentTargetingData[visitorCode] = [];
-    }
-    onConfigurationUpdate(callback) {
-        this.configurationUpdateCallback = callback;
+        throw err;
+      }
     }
-    get storedTargetingData() {
-        return this.targetingData;
+    return (0, _tsRes.Ok)();
+  }
+  addTargetingData(visitorCode, ...data) {
+    if (!(visitorCode in this.targetingData)) {
+      this.targetingData[visitorCode] = [];
     }
-    get experiments() {
-        return this.configurationData.experiments;
+    data.forEach(dataItem => {
+      // --- Note ---
+      // Previous check excludes the failure possibility
+      this.targetingData[visitorCode].push({
+        data: dataItem.data,
+        lastActivityTime: Date.now()
+      });
+    });
+
+    // --- Note ---
+    // `targetingData` should not refresh `lastUpdate` time
+    const result = this.updateStorageData(this.lastUpdate);
+    if (result.ok) {
+      data.forEach(dataItem => {
+        if (!this.unsentTargetingData[visitorCode]) {
+          this.unsentTargetingData[visitorCode] = [];
+        }
+        this.unsentTargetingData[visitorCode].push(dataItem);
+      });
     }
-    get featureFlags() {
-        return this.configurationData.featureFlags;
+    return result;
+  }
+  getUnsentData(visitorCode) {
+    const unsentDataItem = this.unsentTargetingData[visitorCode];
+    if (!unsentDataItem) {
+      return [];
     }
-    get configuration() {
-        return this.configurationData.configuration;
+    return unsentDataItem;
+  }
+  clearUnsentData(visitorCode) {
+    this.unsentTargetingData[visitorCode] = [];
+  }
+  onConfigurationUpdate(callback) {
+    this.configurationUpdateCallback = callback;
+  }
+  get storedTargetingData() {
+    return this.targetingData;
+  }
+  get experiments() {
+    return this.configurationData.experiments;
+  }
+  get featureFlags() {
+    return this.configurationData.featureFlags;
+  }
+  get configuration() {
+    return this.configurationData.configuration;
+  }
+  checkShouldUpdate() {
+    const {
+      featureFlags,
+      experiments,
+      configuration
+    } = this.configurationData;
+    const {
+      updateInterval
+    } = this.settings;
+    if (!featureFlags.length && !experiments.length) {
+      return true;
     }
-    checkShouldUpdate() {
-        const { featureFlags, experiments, configuration } = this.configurationData;
-        const { updateInterval } = this.settings;
-        if (!featureFlags.length && !experiments.length) {
-            return true;
-        }
-        if (configuration.realTimeUpdate) {
-            return true;
-        }
-        const lastUpdateTime = this.lastUpdate.getTime();
-        const updateWindowEdge = Date.now() - updateInterval;
-        return lastUpdateTime < updateWindowEdge;
+    if (configuration.realTimeUpdate) {
+      return true;
     }
-    cleanupOutdatedTargetingData(data) {
-        const currentTime = Date.now();
-        const resultTargetingData = Object.assign({}, data);
-        for (const [key, value] of Object.entries(resultTargetingData)) {
-            if (value) {
-                const resultValue = value.filter((item) => {
-                    const isDataExpired = item.lastActivityTime + constants_1.SESSION_DURATION < currentTime;
-                    return isDataExpired;
-                });
-                resultTargetingData[key] = resultValue;
-            }
-            else {
-                resultTargetingData[key] = [];
-            }
-        }
-        this.targetingData = resultTargetingData;
-        // --- Note ---
-        // `targetingData` should not refresh `lastUpdate` time
-        this.updateStorageData(this.lastUpdate).throw();
+    const lastUpdateTime = this.lastUpdate.getTime();
+    const updateWindowEdge = Date.now() - updateInterval;
+    return lastUpdateTime < updateWindowEdge;
+  }
+  cleanupOutdatedTargetingData(data) {
+    const currentTime = Date.now();
+    const resultTargetingData = _objectSpread({}, data);
+    for (const [key, value] of Object.entries(resultTargetingData)) {
+      if (value) {
+        const resultValue = value.filter(item => {
+          const isDataExpired = item.lastActivityTime + _constants.SESSION_DURATION < currentTime;
+          return isDataExpired;
+        });
+        resultTargetingData[key] = resultValue;
+      } else {
+        resultTargetingData[key] = [];
+      }
     }
-    readStorageData() {
-        const result = this.storage.read();
-        if (result.ok) {
-            const { kameleoonTargetingData, kameleoonConfiguration, lastUpdate } = result.data;
-            this.configurationData = kameleoonConfiguration;
-            this.targetingData = kameleoonTargetingData;
-            this.lastUpdate = new Date(Date.parse(lastUpdate));
-        }
+    this.targetingData = resultTargetingData;
+    // --- Note ---
+    // `targetingData` should not refresh `lastUpdate` time
+    this.updateStorageData(this.lastUpdate).throw();
+  }
+  readStorageData() {
+    const result = this.storage.read();
+    if (result.ok) {
+      const {
+        kameleoonTargetingData,
+        kameleoonConfiguration,
+        lastUpdate
+      } = result.data;
+      this.configurationData = kameleoonConfiguration;
+      this.targetingData = kameleoonTargetingData;
+      this.lastUpdate = new Date(Date.parse(lastUpdate));
     }
-    updateClientConfiguration(timeStamp) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const clientConfigurationResult = yield this.requester.getClientConfiguration(timeStamp);
-            if (!clientConfigurationResult.ok) {
-                return clientConfigurationResult;
-            }
-            // --- Note ---
-            // `featureFlags` field is ommited (v1)
-            // instead `featureFlagConfigurations` is used (v2)
-            const { configuration, experiments, featureFlagConfigurations } = clientConfigurationResult.data;
-            this.configurationData = {
-                configuration,
-                experiments,
-                featureFlags: featureFlagConfigurations,
-            };
-            const result = this.updateStorageData(new Date());
-            if (!result.ok) {
-                return result;
-            }
-            return (0, ts_res_1.Ok)(true);
-        });
+  }
+  async updateClientConfiguration(timeStamp) {
+    // --- Note ---
+    // if `externalClientConfiguration` is passed, fetching is disabled and passed config is used instead
+    if (this.externalClientConfiguration) {
+      // --- Note ---
+      // `featureFlags` field is omitted (v1)
+      // instead `featureFlagConfigurations` is used (v2)
+      const {
+        configuration,
+        experiments,
+        featureFlagConfigurations
+      } = this.externalClientConfiguration;
+      this.configurationData = {
+        configuration,
+        experiments,
+        featureFlags: featureFlagConfigurations
+      };
+    } else {
+      const clientConfigurationResult = await this.requester.getClientConfiguration(timeStamp);
+      if (!clientConfigurationResult.ok) {
+        return clientConfigurationResult;
+      }
+
+      // --- Note ---
+      // `featureFlags` field is omitted (v1)
+      // instead `featureFlagConfigurations` is used (v2)
+      const {
+        configuration,
+        experiments,
+        featureFlagConfigurations
+      } = clientConfigurationResult.data;
+      this.configurationData = {
+        configuration,
+        experiments,
+        featureFlags: featureFlagConfigurations
+      };
     }
-    updateStorageData(lastUpdate) {
-        const data = {
-            kameleoonTargetingData: this.targetingData,
-            kameleoonConfiguration: this.configurationData,
-            lastUpdate: lastUpdate.toString(),
-        };
-        return this.storage.write(data);
+    const result = this.updateStorageData(new Date());
+    if (!result.ok) {
+      return result;
     }
+    return (0, _tsRes.Ok)(true);
+  }
+  updateStorageData(lastUpdate) {
+    const data = {
+      kameleoonTargetingData: this.targetingData,
+      kameleoonConfiguration: this.configurationData,
+      lastUpdate: lastUpdate.toString()
+    };
+    return this.storage.write(data);
+  }
 }
 exports.CampaignConfiguration = CampaignConfiguration;
 //# sourceMappingURL=campaignConfiguration.js.map