@splitsoftware/splitio-commons 2.10.2-rc.3 → 2.10.2-rc.5

package/CHANGES.txt

@@ -1,6 +1,6 @@
 2.11.0 (January XX, 2026)
  - Added metadata to SDK_UPDATE events to indicate the type of update (FLAGS_UPDATE or SEGMENTS_UPDATE) and the names of updated flags or segments.
- - Added metadata to SDK_READY and SDK_READY_FROM_CACHE events, including `initialCacheLoad` (boolean indicating if SDK was loaded from cache) and `lastUpdateTimestamp` (Int64 milliseconds since epoch).
+ - Added metadata to SDK_READY and SDK_READY_FROM_CACHE events, including `initialCacheLoad` (boolean: `true` for fresh install/first app launch, `false` for warm cache/second app launch) and `lastUpdateTimestamp` (Int64 milliseconds since epoch).
 
 2.10.1 (December 18, 2025)
  - Bugfix - Handle `null` prerequisites properly.

package/cjs/readiness/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDK_UPDATE = exports.SDK_READY_FROM_CACHE = exports.SDK_READY = exports.SDK_READY_TIMED_OUT = exports.SDK_SEGMENTS_ARRIVED = exports.SDK_SPLITS_CACHE_LOADED = exports.SDK_SPLITS_ARRIVED = void 0;
+exports.SEGMENTS_UPDATE = exports.FLAGS_UPDATE = exports.SDK_UPDATE = exports.SDK_READY_FROM_CACHE = exports.SDK_READY = exports.SDK_READY_TIMED_OUT = exports.SDK_SEGMENTS_ARRIVED = exports.SDK_SPLITS_CACHE_LOADED = exports.SDK_SPLITS_ARRIVED = void 0;
 // Splits events:
 exports.SDK_SPLITS_ARRIVED = 'state::splits-arrived';
 exports.SDK_SPLITS_CACHE_LOADED = 'state::splits-cache-loaded';
@@ -11,3 +11,6 @@ exports.SDK_READY_TIMED_OUT = 'init::timeout';
 exports.SDK_READY = 'init::ready';
 exports.SDK_READY_FROM_CACHE = 'init::cache-ready';
 exports.SDK_UPDATE = 'state::update';
+// SdkUpdateMetadata types:
+exports.FLAGS_UPDATE = 'FLAGS_UPDATE';
+exports.SEGMENTS_UPDATE = 'SEGMENTS_UPDATE';

package/cjs/readiness/readinessManager.js

@@ -41,6 +41,7 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
     }
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
+    var cacheLastUpdateTimestamp = null;
     if (splits.splitsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
@@ -68,17 +69,17 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
     splits.initCallbacks.push(__init);
     if (splits.hasInit)
         __init();
-    function checkIsReadyFromCache() {
+    function checkIsReadyFromCache(cacheMetadata) {
         isReadyFromCache = true;
+        cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                var metadata = {
-                    initialCacheLoad: true,
-                    lastUpdateTimestamp: lastUpdate
-                };
-                gate.emit(constants_1.SDK_READY_FROM_CACHE, metadata);
+                gate.emit(constants_1.SDK_READY_FROM_CACHE, {
+                    initialCacheLoad: !cacheMetadata.isCacheValid,
+                    lastUpdateTimestamp: cacheLastUpdateTimestamp
+                });
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -104,19 +105,18 @@ function readinessManagerFactory(EventEmitter, settings, splits, isShared) {
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
-                    syncLastUpdate();
                     var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        var metadataFromCache = {
-                            initialCacheLoad: false,
-                            lastUpdateTimestamp: lastUpdate
+                        var metadataReadyFromCache = {
+                            initialCacheLoad: true,
+                            lastUpdateTimestamp: null // No cache timestamp when fresh install
                         };
-                        gate.emit(constants_1.SDK_READY_FROM_CACHE, metadataFromCache);
+                        gate.emit(constants_1.SDK_READY_FROM_CACHE, metadataReadyFromCache);
                     }
                     var metadataReady = {
-                        initialCacheLoad: wasReadyFromCache,
-                        lastUpdateTimestamp: lastUpdate
+                        initialCacheLoad: !wasReadyFromCache,
+                        lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
                     };
                     gate.emit(constants_1.SDK_READY, metadataReady);
                 }

package/cjs/sdkFactory/index.js

@@ -46,17 +46,17 @@ function sdkFactory(params) {
                 return;
             }
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
-            readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
         }
     });
     var fallbackTreatmentsCalculator = new fallbackTreatmentsCalculator_1.FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         (0, setRolloutPlan_1.setRolloutPlan)(log, initialRolloutPlan, storage, key && (0, key_1.getMatching)(key));
         if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);

package/cjs/storages/inLocalStorage/index.js

@@ -60,7 +60,10 @@ function InLocalStorage(options) {
             telemetry: (0, TelemetryCacheInMemory_1.shouldRecordTelemetry)(params) ? new TelemetryCacheInMemory_1.TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS_1.UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+                if (!validateCachePromise) {
+                    validateCachePromise = (0, validateCache_1.validateCache)(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+                }
+                return validateCachePromise;
             },
             save: function () {
                 return storage.save && storage.save();

package/cjs/storages/inLocalStorage/validateCache.js

@@ -55,12 +55,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
 function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
         var isThereCache = splits.getChangeNumber() > -1;
+        // Get lastUpdateTimestamp from storage
+        var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+        var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+        var lastUpdateTimestamp = (!(0, lang_1.isNaNNumber)(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
             splits.clear();
             rbSegments.clear();
@@ -76,10 +80,16 @@ function validateCache(options, storage, settings, keys, splits, rbSegments, seg
             // Persist clear
             if (storage.save)
                 storage.save();
-            return false;
+            return {
+                isCacheValid: false,
+                lastUpdateTimestamp: null
+            };
         }
         // Check if ready from cache
-        return isThereCache;
+        return {
+            isCacheValid: isThereCache,
+            lastUpdateTimestamp: lastUpdateTimestamp
+        };
     });
 }
 exports.validateCache = validateCache;

package/cjs/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -6,7 +6,6 @@ var syncTask_1 = require("../../syncTask");
 var constants_1 = require("../../../utils/constants");
 var constants_2 = require("../../../readiness/constants");
 var constants_3 = require("../../../logger/constants");
-var types_1 = require("../../polling/types");
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
@@ -43,15 +42,16 @@ function fromObjectUpdaterFactory(splitsParser, storage, readiness, settings) {
                 splitsCache.clear(),
                 splitsCache.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: types_1.SdkUpdateMetadataKeys.FLAGS_UPDATE, names: [] });
+                readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED, { type: constants_2.FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                         // Emits SDK_READY
-                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: types_1.SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+                        readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED, { type: constants_2.SEGMENTS_UPDATE, names: [] });
                     });
                 }
                 return true;

package/cjs/sync/polling/types.js

@@ -1,17 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SdkUpdateMetadataKeys = void 0;
-/**
- * Metadata keys for SDK update events.
- */
-var SdkUpdateMetadataKeys;
-(function (SdkUpdateMetadataKeys) {
-    /**
-     * The update event emitted when the SDK cache is updated with new data for flags.
-     */
-    SdkUpdateMetadataKeys["FLAGS_UPDATE"] = "FLAGS_UPDATE";
-    /**
-     * The update event emitted when the SDK cache is updated with new data for segments.
-     */
-    SdkUpdateMetadataKeys["SEGMENTS_UPDATE"] = "SEGMENTS_UPDATE";
-})(SdkUpdateMetadataKeys = exports.SdkUpdateMetadataKeys || (exports.SdkUpdateMetadataKeys = {}));

package/cjs/sync/polling/updaters/mySegmentsUpdater.js

@@ -6,7 +6,6 @@ var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var constants_3 = require("../../streaming/constants");
 var AbstractSplitsCacheSync_1 = require("../../../storages/AbstractSplitsCacheSync");
-var types_1 = require("../types");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -40,7 +39,7 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
         // Notify update if required
         if ((0, AbstractSplitsCacheSync_1.usesSegmentsSync)(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: types_1.SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+            segmentsEventEmitter.emit(constants_1.SDK_SEGMENTS_ARRIVED, { type: constants_1.SEGMENTS_UPDATE, names: [] });
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache, till) {

package/cjs/sync/polling/updaters/segmentChangesUpdater.js

@@ -4,7 +4,6 @@ exports.segmentChangesUpdaterFactory = void 0;
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
 var timeout_1 = require("../../../utils/promise/timeout");
-var types_1 = require("../types");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -67,12 +66,13 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    var metadata = {
-                        type: types_1.SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-                        names: []
-                    };
-                    if (readiness)
+                    if (readiness) {
+                        var metadata = {
+                            type: constants_1.SEGMENTS_UPDATE,
+                            names: []
+                        };
                         readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED, metadata);
+                    }
                 }
                 return true;
             });

package/cjs/sync/polling/updaters/splitChangesUpdater.js

@@ -8,7 +8,6 @@ var lang_1 = require("../../../utils/lang");
 var constants_3 = require("../../../utils/constants");
 var sets_1 = require("../../../utils/lang/sets");
 var constants_4 = require("../../streaming/constants");
-var types_1 = require("../types");
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -165,13 +164,14 @@ function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, splitFilt
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
-                            var metadata = {
-                                type: updatedFlags.length > 0 ? types_1.SdkUpdateMetadataKeys.FLAGS_UPDATE : types_1.SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-                                names: updatedFlags.length > 0 ? updatedFlags : []
-                            };
                             // emit SDK events
-                            if (emitSplitsArrivedEvent)
+                            if (emitSplitsArrivedEvent) {
+                                var metadata = {
+                                    type: updatedFlags.length > 0 ? constants_1.FLAGS_UPDATE : constants_1.SEGMENTS_UPDATE,
+                                    names: updatedFlags.length > 0 ? updatedFlags : []
+                                };
                                 splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, metadata);
+                            }
                             return true;
                         });
                     }

package/cjs/sync/syncManagerOnline.js

@@ -71,13 +71,14 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
                 running = true;
                 // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
                 submitterManager.start(!(0, consent_1.isConsentGranted)(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                     if (!running)
                         return;
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(constants_4.SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                     }
                     // start syncing splits and segments
                     if (pollingManager) {

package/cjs/utils/settingsValidation/storage/storageCS.js

@@ -6,7 +6,7 @@ var constants_1 = require("../../../logger/constants");
 var constants_2 = require("../../../utils/constants");
 function __InLocalStorageMockFactory(params) {
     var result = (0, InMemoryStorageCS_1.InMemoryStorageCSFactory)(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 exports.__InLocalStorageMockFactory = __InLocalStorageMockFactory;

package/esm/readiness/constants.js

@@ -8,3 +8,6 @@ export var SDK_READY_TIMED_OUT = 'init::timeout';
 export var SDK_READY = 'init::ready';
 export var SDK_READY_FROM_CACHE = 'init::cache-ready';
 export var SDK_UPDATE = 'state::update';
+// SdkUpdateMetadata types:
+export var FLAGS_UPDATE = 'FLAGS_UPDATE';
+export var SEGMENTS_UPDATE = 'SEGMENTS_UPDATE';

package/esm/readiness/readinessManager.js

@@ -38,6 +38,7 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     }
     // emit SDK_READY_FROM_CACHE
     var isReadyFromCache = false;
+    var cacheLastUpdateTimestamp = null;
     if (splits.splitsCacheLoaded)
         isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
     else
@@ -65,17 +66,17 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
     splits.initCallbacks.push(__init);
     if (splits.hasInit)
         __init();
-    function checkIsReadyFromCache() {
+    function checkIsReadyFromCache(cacheMetadata) {
         isReadyFromCache = true;
+        cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
         // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
         if (!isReady && !isDestroyed) {
             try {
                 syncLastUpdate();
-                var metadata = {
-                    initialCacheLoad: true,
-                    lastUpdateTimestamp: lastUpdate
-                };
-                gate.emit(SDK_READY_FROM_CACHE, metadata);
+                gate.emit(SDK_READY_FROM_CACHE, {
+                    initialCacheLoad: !cacheMetadata.isCacheValid,
+                    lastUpdateTimestamp: cacheLastUpdateTimestamp
+                });
             }
             catch (e) {
                 // throws user callback exceptions in next tick
@@ -101,19 +102,18 @@ export function readinessManagerFactory(EventEmitter, settings, splits, isShared
                 clearTimeout(readyTimeoutId);
                 isReady = true;
                 try {
-                    syncLastUpdate();
                     var wasReadyFromCache = isReadyFromCache;
                     if (!isReadyFromCache) {
                         isReadyFromCache = true;
-                        var metadataFromCache = {
-                            initialCacheLoad: false,
-                            lastUpdateTimestamp: lastUpdate
+                        var metadataReadyFromCache = {
+                            initialCacheLoad: true,
+                            lastUpdateTimestamp: null // No cache timestamp when fresh install
                         };
-                        gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
+                        gate.emit(SDK_READY_FROM_CACHE, metadataReadyFromCache);
                     }
                     var metadataReady = {
-                        initialCacheLoad: wasReadyFromCache,
-                        lastUpdateTimestamp: lastUpdate
+                        initialCacheLoad: !wasReadyFromCache,
+                        lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
                     };
                     gate.emit(SDK_READY, metadataReady);
                 }

package/esm/sdkFactory/index.js

@@ -43,17 +43,17 @@ export function sdkFactory(params) {
                 return;
             }
             readiness.splits.emit(SDK_SPLITS_ARRIVED);
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
         },
         onReadyFromCacheCb: function () {
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
         }
     });
     var fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
     if (initialRolloutPlan) {
         setRolloutPlan(log, initialRolloutPlan, storage, key && getMatching(key));
         if (storage.splits.getChangeNumber() > -1)
-            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
     var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);

package/esm/storages/inLocalStorage/index.js

@@ -57,7 +57,10 @@ export function InLocalStorage(options) {
             telemetry: shouldRecordTelemetry(params) ? new TelemetryCacheInMemory(splits, segments) : undefined,
             uniqueKeys: new UniqueKeysCacheInMemoryCS(),
             validateCache: function () {
-                return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+                if (!validateCachePromise) {
+                    validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+                }
+                return validateCachePromise;
             },
             save: function () {
                 return storage.save && storage.save();

package/esm/storages/inLocalStorage/validateCache.js

@@ -52,12 +52,16 @@ function validateExpiration(options, storage, settings, keys, currentTimestamp,
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
 export function validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments) {
     return Promise.resolve(storage.load && storage.load()).then(function () {
         var currentTimestamp = Date.now();
         var isThereCache = splits.getChangeNumber() > -1;
+        // Get lastUpdateTimestamp from storage
+        var lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+        var lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+        var lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
         if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
             splits.clear();
             rbSegments.clear();
@@ -73,9 +77,15 @@ export function validateCache(options, storage, settings, keys, splits, rbSegmen
             // Persist clear
             if (storage.save)
                 storage.save();
-            return false;
+            return {
+                isCacheValid: false,
+                lastUpdateTimestamp: null
+            };
         }
         // Check if ready from cache
-        return isThereCache;
+        return {
+            isCacheValid: isThereCache,
+            lastUpdateTimestamp: lastUpdateTimestamp
+        };
     });
 }

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

@@ -1,9 +1,8 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
-import { SdkUpdateMetadataKeys } from '../../polling/types';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
  */
@@ -40,15 +39,16 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 splitsCache.clear(),
                 splitsCache.update(splits, [], Date.now())
             ]).then(function () {
-                readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: SdkUpdateMetadataKeys.FLAGS_UPDATE, names: [] });
+                readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
                 if (startingUp) {
                     startingUp = false;
-                    Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                    Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                         // Emits SDK_READY
-                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
                     });
                 }
                 return true;

package/esm/sync/polling/types.js

@@ -1,14 +1 @@
-/**
- * Metadata keys for SDK update events.
- */
-export var SdkUpdateMetadataKeys;
-(function (SdkUpdateMetadataKeys) {
-    /**
-     * The update event emitted when the SDK cache is updated with new data for flags.
-     */
-    SdkUpdateMetadataKeys["FLAGS_UPDATE"] = "FLAGS_UPDATE";
-    /**
-     * The update event emitted when the SDK cache is updated with new data for segments.
-     */
-    SdkUpdateMetadataKeys["SEGMENTS_UPDATE"] = "SEGMENTS_UPDATE";
-})(SdkUpdateMetadataKeys || (SdkUpdateMetadataKeys = {}));
+export {};

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -1,9 +1,8 @@
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
-import { SdkUpdateMetadataKeys } from '../types';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -37,7 +36,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
         // Notify update if required
         if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
-            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+            segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
         }
     }
     function _mySegmentsUpdater(retry, segmentsData, noCache, till) {

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -1,7 +1,6 @@
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
-import { SdkUpdateMetadataKeys } from '../types';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -64,12 +63,13 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 // if at least one segment fetch succeeded, mark segments ready
                 if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
-                    var metadata = {
-                        type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-                        names: []
-                    };
-                    if (readiness)
+                    if (readiness) {
+                        var metadata = {
+                            type: SEGMENTS_UPDATE,
+                            names: []
+                        };
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+                    }
                 }
                 return true;
             });

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -1,11 +1,10 @@
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT } from '../../../utils/constants';
 import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
-import { SdkUpdateMetadataKeys } from '../types';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -160,13 +159,14 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, storage, sp
                         return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                             .catch(function () { return false; } /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                             .then(function (emitSplitsArrivedEvent) {
-                            var metadata = {
-                                type: updatedFlags.length > 0 ? SdkUpdateMetadataKeys.FLAGS_UPDATE : SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-                                names: updatedFlags.length > 0 ? updatedFlags : []
-                            };
                             // emit SDK events
-                            if (emitSplitsArrivedEvent)
+                            if (emitSplitsArrivedEvent) {
+                                var metadata = {
+                                    type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
+                                    names: updatedFlags.length > 0 ? updatedFlags : []
+                                };
                                 splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
+                            }
                             return true;
                         });
                     }

package/esm/sync/syncManagerOnline.js

@@ -68,13 +68,14 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 running = true;
                 // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
                 submitterManager.start(!isConsentGranted(settings));
-                return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then(function (isCacheLoaded) {
+                return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then(function (cacheMetadata) {
                     if (!running)
                         return;
                     if (startFirstTime) {
                         // Emits SDK_READY_FROM_CACHE
-                        if (isCacheLoaded)
-                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        if (cacheMetadata.isCacheValid) {
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+                        }
                     }
                     // start syncing splits and segments
                     if (pollingManager) {

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -3,7 +3,7 @@ import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
-    result.validateCache = function () { return Promise.resolve(true); }; // to emit SDK_READY_FROM_CACHE
+    result.validateCache = function () { return Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); }; // to emit SDK_READY_FROM_CACHE
     return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.10.2-rc.3",
+  "version": "2.10.2-rc.5",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/readiness/constants.ts

@@ -10,3 +10,7 @@ export const SDK_READY_TIMED_OUT = 'init::timeout';
 export const SDK_READY = 'init::ready';
 export const SDK_READY_FROM_CACHE = 'init::cache-ready';
 export const SDK_UPDATE = 'state::update';
+
+// SdkUpdateMetadata types:
+export const FLAGS_UPDATE =  'FLAGS_UPDATE';
+export const SEGMENTS_UPDATE = 'SEGMENTS_UPDATE';

package/src/readiness/readinessManager.ts

@@ -3,6 +3,7 @@ import { ISettings } from '../types';
 import SplitIO from '../../types/splitio';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
+import { CacheValidationMetadata } from '../storages/inLocalStorage/validateCache';
 
 function splitsEventEmitterFactory(EventEmitter: new () => SplitIO.IEventEmitter): ISplitsEventEmitter {
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
@@ -55,6 +56,7 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
+  let cacheLastUpdateTimestamp: number | null = null;
   if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
   else splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
 
@@ -84,17 +86,17 @@ export function readinessManagerFactory(
   splits.initCallbacks.push(__init);
   if (splits.hasInit) __init();
 
-  function checkIsReadyFromCache() {
+  function checkIsReadyFromCache(cacheMetadata: CacheValidationMetadata) {
     isReadyFromCache = true;
+    cacheLastUpdateTimestamp = cacheMetadata.lastUpdateTimestamp;
     // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
     if (!isReady && !isDestroyed) {
       try {
         syncLastUpdate();
-        const metadata: SplitIO.SdkReadyMetadata = {
-          initialCacheLoad: true,
-          lastUpdateTimestamp: lastUpdate
-        };
-        gate.emit(SDK_READY_FROM_CACHE, metadata);
+        gate.emit(SDK_READY_FROM_CACHE, {
+          initialCacheLoad: !cacheMetadata.isCacheValid,
+          lastUpdateTimestamp: cacheLastUpdateTimestamp
+        });
       } catch (e) {
         // throws user callback exceptions in next tick
         setTimeout(() => { throw e; }, 0);
@@ -117,19 +119,18 @@ export function readinessManagerFactory(
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
-          syncLastUpdate();
           const wasReadyFromCache = isReadyFromCache;
           if (!isReadyFromCache) {
             isReadyFromCache = true;
-            const metadataFromCache: SplitIO.SdkReadyMetadata = {
-              initialCacheLoad: false,
-              lastUpdateTimestamp: lastUpdate
+            const metadataReadyFromCache: SplitIO.SdkReadyMetadata = {
+              initialCacheLoad: true,
+              lastUpdateTimestamp: null // No cache timestamp when fresh install
             };
-            gate.emit(SDK_READY_FROM_CACHE, metadataFromCache);
+            gate.emit(SDK_READY_FROM_CACHE, metadataReadyFromCache);
           }
           const metadataReady: SplitIO.SdkReadyMetadata = {
-            initialCacheLoad: wasReadyFromCache,
-            lastUpdateTimestamp: lastUpdate
+            initialCacheLoad: !wasReadyFromCache,
+            lastUpdateTimestamp: wasReadyFromCache ? cacheLastUpdateTimestamp : null
           };
           gate.emit(SDK_READY, metadataReady);
         } catch (e) {

package/src/sdkFactory/index.ts

@@ -54,10 +54,10 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
         return;
       }
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
-      readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { isCacheValid: true, lastUpdateTimestamp: null });
     },
     onReadyFromCacheCb() {
-      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
     }
   });
 
@@ -65,7 +65,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
   if (initialRolloutPlan) {
     setRolloutPlan(log, initialRolloutPlan, storage as IStorageSync, key && getMatching(key));
-    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { isCacheValid: true, lastUpdateTimestamp: null });
   }
 
   const clients: Record<string, SplitIO.IBasicClient> = {};

package/src/storages/inLocalStorage/index.ts

@@ -14,7 +14,7 @@ import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
-import { validateCache } from './validateCache';
+import { validateCache, CacheValidationMetadata } from './validateCache';
 import { ILogger } from '../../logger/types';
 import SplitIO from '../../../types/splitio';
 import { storageAdapter } from './storageAdapter';
@@ -54,7 +54,7 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
     const rbSegments = new RBSegmentsCacheInLocal(settings, keys, storage);
     const segments = new MySegmentsCacheInLocal(log, keys, storage);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey), storage);
-    let validateCachePromise: Promise<boolean> | undefined;
+    let validateCachePromise: Promise<CacheValidationMetadata> | undefined;
 
     return {
       splits,
@@ -68,7 +68,10 @@ export function InLocalStorage(options: SplitIO.InLocalStorageOptions = {}): ISt
       uniqueKeys: new UniqueKeysCacheInMemoryCS(),
 
       validateCache() {
-        return validateCachePromise || (validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments));
+        if (!validateCachePromise) {
+          validateCachePromise = validateCache(options, storage, settings, keys, splits, rbSegments, segments, largeSegments);
+        }
+        return validateCachePromise;
       },
 
       save() {

package/src/storages/inLocalStorage/validateCache.ts

@@ -12,6 +12,11 @@ import { StorageAdapter } from '../types';
 const DEFAULT_CACHE_EXPIRATION_IN_DAYS = 10;
 const MILLIS_IN_A_DAY = 86400000;
 
+export interface CacheValidationMetadata {
+  isCacheValid: boolean;
+  lastUpdateTimestamp: number | null;
+}
+
 /**
  * Validates if cache should be cleared and sets the cache `hash` if needed.
  *
@@ -66,14 +71,19 @@ function validateExpiration(options: SplitIO.InLocalStorageOptions, storage: Sto
  * - its hash has changed, i.e., the SDK key, flags filter criteria or flags spec version was modified
  * - `clearOnInit` was set and cache was not cleared in the last 24 hours
  *
- * @returns `true` if cache is ready to be used, `false` otherwise (cache was cleared or there is no cache)
+ * @returns Metadata object with `isCacheValid` (true if cache is ready to be used, false otherwise) and `lastUpdateTimestamp` (timestamp of last cache update or null)
  */
-export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<boolean> {
+export function validateCache(options: SplitIO.InLocalStorageOptions, storage: StorageAdapter, settings: ISettings, keys: KeyBuilderCS, splits: SplitsCacheInLocal, rbSegments: RBSegmentsCacheInLocal, segments: MySegmentsCacheInLocal, largeSegments: MySegmentsCacheInLocal): Promise<CacheValidationMetadata> {
 
   return Promise.resolve(storage.load && storage.load()).then(() => {
     const currentTimestamp = Date.now();
     const isThereCache = splits.getChangeNumber() > -1;
 
+    // Get lastUpdateTimestamp from storage
+    const lastUpdatedTimestampStr = storage.getItem(keys.buildLastUpdatedKey());
+    const lastUpdatedTimestamp = lastUpdatedTimestampStr ? parseInt(lastUpdatedTimestampStr, 10) : null;
+    const lastUpdateTimestamp = (!isNaNNumber(lastUpdatedTimestamp) && lastUpdatedTimestamp !== null) ? lastUpdatedTimestamp : null;
+
     if (validateExpiration(options, storage, settings, keys, currentTimestamp, isThereCache)) {
       splits.clear();
       rbSegments.clear();
@@ -90,10 +100,16 @@ export function validateCache(options: SplitIO.InLocalStorageOptions, storage: S
       // Persist clear
       if (storage.save) storage.save();
 
-      return false;
+      return {
+        isCacheValid: false,
+        lastUpdateTimestamp: null
+      };
     }
 
     // Check if ready from cache
-    return isThereCache;
+    return {
+      isCacheValid: isThereCache,
+      lastUpdateTimestamp
+    };
   });
 }

package/src/storages/types.ts

@@ -499,7 +499,7 @@ export interface IStorageSync extends IStorageBase<
   IUniqueKeysCacheSync
 > {
   // Defined in client-side
-  validateCache?: () => Promise<boolean>,
+  validateCache?: () => Promise<{ isCacheValid: boolean; lastUpdateTimestamp: number | null }>,
   largeSegments?: ISegmentsCacheSync,
 }
 

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -7,9 +7,8 @@ import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
-import { SdkUpdateMetadataKeys } from '../../polling/types';
 
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -56,15 +55,17 @@ export function fromObjectUpdaterFactory(
         splitsCache.clear(), // required to sync removed splits from mock
         splitsCache.update(splits, [], Date.now())
       ]).then(() => {
-        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: SdkUpdateMetadataKeys.FLAGS_UPDATE, names: [] });
+        readiness.splits.emit(SDK_SPLITS_ARRIVED, { type: FLAGS_UPDATE, names: [] });
 
         if (startingUp) {
           startingUp = false;
-          Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
+          Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then((cacheMetadata) => {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheMetadata.isCacheValid) {
+              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+            }
             // Emits SDK_READY
-            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
           });
         }
         return true;

package/src/sync/polling/types.ts

@@ -4,20 +4,6 @@ import { IStorageSync } from '../../storages/types';
 import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
-/**
- * Metadata keys for SDK update events.
- */
-export enum SdkUpdateMetadataKeys {
-  /**
-   * The update event emitted when the SDK cache is updated with new data for flags.
-   */
-  FLAGS_UPDATE = 'FLAGS_UPDATE',
-  /**
-   * The update event emitted when the SDK cache is updated with new data for segments.
-   */
-  SEGMENTS_UPDATE = 'SEGMENTS_UPDATE'
-}
-
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit | IRBSegment, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -2,14 +2,13 @@ import { IMySegmentsFetcher } from '../fetchers/types';
 import { IStorageSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
 import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 import { usesSegmentsSync } from '../../../storages/AbstractSplitsCacheSync';
-import { SdkUpdateMetadataKeys } from '../types';
 
 type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -57,7 +56,7 @@ export function mySegmentsUpdaterFactory(
     // Notify update if required
     if (usesSegmentsSync(storage) && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE, names: [] });
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED, { type: SEGMENTS_UPDATE, names: [] });
     }
   }
 

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -1,12 +1,11 @@
 import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SEGMENTS_ARRIVED, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { timeout } from '../../../utils/promise/timeout';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
-import { SdkUpdateMetadataKeys } from '../types';
 
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
@@ -86,11 +85,13 @@ export function segmentChangesUpdaterFactory(
         // if at least one segment fetch succeeded, mark segments ready
         if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
-          const metadata: SdkUpdateMetadata = {
-            type: SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-            names: []
-          };
-          if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+          if (readiness) {
+            const metadata: SdkUpdateMetadata = {
+              type: SEGMENTS_UPDATE,
+              names: []
+            };
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED, metadata);
+          }
         }
         return true;
       });

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -3,7 +3,7 @@ import { ISplitChangesFetcher } from '../fetchers/types';
 import { IRBSegment, ISplit, ISplitChangesResponse, ISplitFiltersValidation, MaybeThenable } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, FLAGS_UPDATE, SEGMENTS_UPDATE } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_UPDATE, SYNC_RBS_UPDATE, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
@@ -11,7 +11,6 @@ import { IN_RULE_BASED_SEGMENT, IN_SEGMENT, RULE_BASED_SEGMENT, STANDARD_SEGMENT
 import { setToArray } from '../../../utils/lang/sets';
 import { SPLIT_UPDATE } from '../../streaming/constants';
 import { SdkUpdateMetadata } from '../../../../types/splitio';
-import { SdkUpdateMetadataKeys } from '../types';
 
 export type InstantUpdate = { payload: ISplit | IRBSegment, changeNumber: number, type: string };
 type SplitChangesUpdater = (noCache?: boolean, till?: number, instantUpdate?: InstantUpdate) => Promise<boolean>
@@ -198,12 +197,14 @@ export function splitChangesUpdaterFactory(
               return Promise.resolve(!splitsEventEmitter.splitsArrived || ((ffChanged || rbsChanged) && (isClientSide || checkAllSegmentsExist(segments))))
                 .catch(() => false /** noop. just to handle a possible `checkAllSegmentsExist` rejection, before emitting SDK event */)
                 .then(emitSplitsArrivedEvent => {
-                  const metadata: SdkUpdateMetadata = {
-                    type: updatedFlags.length > 0 ? SdkUpdateMetadataKeys.FLAGS_UPDATE : SdkUpdateMetadataKeys.SEGMENTS_UPDATE,
-                    names: updatedFlags.length > 0 ? updatedFlags : []
-                  };
                   // emit SDK events
-                  if (emitSplitsArrivedEvent) splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
+                  if (emitSplitsArrivedEvent) {
+                    const metadata: SdkUpdateMetadata = {
+                      type: updatedFlags.length > 0 ? FLAGS_UPDATE : SEGMENTS_UPDATE,
+                      names: updatedFlags.length > 0 ? updatedFlags : []
+                    };
+                    splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, metadata);
+                  }
                   return true;
                 });
             }

package/src/sync/syncManagerOnline.ts

@@ -92,12 +92,14 @@ export function syncManagerOnlineFactory(
         // @TODO once event, impression and telemetry storages support persistence, call when `validateCache` promise is resolved
         submitterManager.start(!isConsentGranted(settings));
 
-        return Promise.resolve(storage.validateCache ? storage.validateCache() : false).then((isCacheLoaded) => {
+        return Promise.resolve(storage.validateCache ? storage.validateCache() : { isCacheValid: false, lastUpdateTimestamp: null }).then((cacheMetadata) => {
           if (!running) return;
 
           if (startFirstTime) {
             // Emits SDK_READY_FROM_CACHE
-            if (isCacheLoaded) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            if (cacheMetadata.isCacheValid) {
+              readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, cacheMetadata);
+            }
 
           }
 

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -8,7 +8,7 @@ import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
   const result = InMemoryStorageCSFactory(params);
-  result.validateCache = () => Promise.resolve(true); // to emit SDK_READY_FROM_CACHE
+  result.validateCache = () => Promise.resolve({ isCacheValid: true, lastUpdateTimestamp: null }); // to emit SDK_READY_FROM_CACHE
   return result;
 }
 __InLocalStorageMockFactory.type = STORAGE_MEMORY;

package/types/splitio.d.ts

@@ -530,7 +530,7 @@ declare namespace SplitIO {
     /**
      * Timestamp in milliseconds since epoch when the event was emitted.
      */
-    lastUpdateTimestamp: number
+    lastUpdateTimestamp: number | null
   }
 
   /**