@statsig/client-core 0.0.1-beta.2 → 0.0.1-beta.20

package/README.md

@@ -5,4 +5,4 @@
 
 The package that contains all the common logic shared by the various Statsig Javascript packages.
 
-Learn more by visiting: https://docs.statsig.com/client/jsClientSDK
+Learn more by visiting: https://docs.statsig.com/client/javascript-sdk

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statsig/client-core",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.20",
   "dependencies": {},
   "type": "commonjs",
   "main": "./src/index.js",

package/src/$_StatsigGlobal.js

@@ -1,14 +1,10 @@
 "use strict";
+var _a, _b, _c;
 Object.defineProperty(exports, "__esModule", { value: true });
-var statsigGlobal = {};
-if (typeof window !== 'undefined') {
-    window.__STATSIG__ = statsigGlobal;
-}
-if (typeof global !== 'undefined') {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    global.__STATSIG__ = statsigGlobal;
-}
-if (typeof globalThis !== 'undefined') {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-    globalThis.__STATSIG__ = statsigGlobal;
-}
+const _window = typeof window !== 'undefined' ? window : {};
+const _global = typeof global !== 'undefined' ? global : {};
+const _globalThis = typeof globalThis !== 'undefined' ? globalThis : {};
+const statsigGlobal = (_c = (_b = (_a = _window.__STATSIG__) !== null && _a !== void 0 ? _a : _global.__STATSIG__) !== null && _b !== void 0 ? _b : _globalThis.__STATSIG__) !== null && _c !== void 0 ? _c : {};
+_window.__STATSIG__ = statsigGlobal;
+_global.__STATSIG__ = statsigGlobal;
+_globalThis.__STATSIG__ = statsigGlobal;

package/src/ClientInterfaces.d.ts

@@ -1,28 +1,35 @@
-import { EvaluationOptions } from './StatsigClientBase';
+import { DynamicConfigEvaluationOptions, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions } from './EvaluationOptions';
 import { StatsigClientEventEmitterInterface } from './StatsigClientEventEmitter';
+import { EvaluationsDataAdapter, SpecsDataAdapter } from './StatsigDataAdapter';
 import { StatsigEvent } from './StatsigEvent';
+import { StatsigRuntimeMutableOptions } from './StatsigOptionsCommon';
 import { DynamicConfig, Experiment, FeatureGate, Layer } from './StatsigTypes';
 import { StatsigUser } from './StatsigUser';
 export interface StatsigClientCommonInterface extends StatsigClientEventEmitterInterface {
-    initialize(): Promise<void>;
+    initializeSync(): void;
+    initializeAsync(): Promise<void>;
     shutdown(): Promise<void>;
+    updateRuntimeOptions(options: StatsigRuntimeMutableOptions): void;
 }
 export interface OnDeviceEvaluationsInterface extends StatsigClientCommonInterface {
-    checkGate(name: string, user: StatsigUser, options: EvaluationOptions): boolean;
-    getFeatureGate(name: string, user: StatsigUser, options: EvaluationOptions): FeatureGate;
-    getDynamicConfig(name: string, user: StatsigUser, options: EvaluationOptions): DynamicConfig;
-    getExperiment(name: string, user: StatsigUser, options: EvaluationOptions): Experiment;
-    getLayer(name: string, user: StatsigUser, options: EvaluationOptions): Layer;
+    readonly dataAdapter: SpecsDataAdapter;
+    checkGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): boolean;
+    getFeatureGate(name: string, user: StatsigUser, options?: FeatureGateEvaluationOptions): FeatureGate;
+    getDynamicConfig(name: string, user: StatsigUser, options?: DynamicConfigEvaluationOptions): DynamicConfig;
+    getExperiment(name: string, user: StatsigUser, options?: ExperimentEvaluationOptions): Experiment;
+    getLayer(name: string, user: StatsigUser, options?: LayerEvaluationOptions): Layer;
     logEvent(event: StatsigEvent, user: StatsigUser): void;
 }
 export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
+    readonly dataAdapter: EvaluationsDataAdapter;
     getCurrentUser(): StatsigUser;
-    updateUser(user: StatsigUser): Promise<void>;
-    checkGate(name: string, options: EvaluationOptions): boolean;
-    getFeatureGate(name: string, options: EvaluationOptions): FeatureGate;
-    getDynamicConfig(name: string, options: EvaluationOptions): DynamicConfig;
-    getExperiment(name: string, options: EvaluationOptions): Experiment;
-    getLayer(name: string, options: EvaluationOptions): Layer;
+    updateUserSync(user: StatsigUser): void;
+    updateUserAsync(user: StatsigUser): Promise<void>;
+    checkGate(name: string, options?: FeatureGateEvaluationOptions): boolean;
+    getFeatureGate(name: string, options?: FeatureGateEvaluationOptions): FeatureGate;
+    getDynamicConfig(name: string, options?: DynamicConfigEvaluationOptions): DynamicConfig;
+    getExperiment(name: string, options?: ExperimentEvaluationOptions): Experiment;
+    getLayer(name: string, options?: LayerEvaluationOptions): Layer;
     logEvent(event: StatsigEvent): void;
 }
 export type StatsigClientInterface = OnDeviceEvaluationsInterface | PrecomputedEvaluationsInterface;

package/src/DataAdapterCore.d.ts

@@ -0,0 +1,32 @@
+import { ErrorBoundary } from './ErrorBoundary';
+import { DataAdapterResult } from './StatsigDataAdapter';
+import { StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { StatsigUser } from './StatsigUser';
+export declare abstract class DataAdapterCore {
+    private _adapterName;
+    private _cacheSuffix;
+    protected _errorBoundary: ErrorBoundary | null;
+    private _sdkKey;
+    private _inMemoryCache;
+    private _lastModifiedStoreKey;
+    protected constructor(_adapterName: string, _cacheSuffix: string);
+    attach(sdkKey: string, _options: StatsigOptionsCommon | null): void;
+    getDataSync(user?: StatsigUser | undefined): DataAdapterResult | null;
+    getDataAsync(current: DataAdapterResult | null, user?: StatsigUser): Promise<DataAdapterResult | null>;
+    prefetchData(user?: StatsigUser | undefined): Promise<void>;
+    setData(data: string, user?: StatsigUser): void;
+    /**
+     * (Internal Use Only) - Used by \@statsig/react-native-bindings to prime the cache from AsyncStorage
+     *
+     * @param {Record<string, DataAdapterResult>} cache The values to merge into _inMemoryCache
+     */
+    __primeInMemoryCache(cache: Record<string, DataAdapterResult>): void;
+    protected abstract _fetchFromNetwork(current: string | null, user?: StatsigUser): Promise<string | null>;
+    private _fetchLatest;
+    protected _getSdkKey(): string;
+    protected _getCacheKey(user?: StatsigUser): string;
+    protected _addToInMemoryCache(cacheKey: string, result: DataAdapterResult): void;
+    private _loadFromCache;
+    private _writeToCache;
+    private _runLocalStorageCacheEviction;
+}

package/src/DataAdapterCore.js

@@ -0,0 +1,167 @@
+"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 });
+exports.DataAdapterCore = void 0;
+const ErrorBoundary_1 = require("./ErrorBoundary");
+const Log_1 = require("./Log");
+const Monitoring_1 = require("./Monitoring");
+const StatsigDataAdapter_1 = require("./StatsigDataAdapter");
+const StatsigUser_1 = require("./StatsigUser");
+const StorageProvider_1 = require("./StorageProvider");
+const TypedJsonParse_1 = require("./TypedJsonParse");
+const CACHE_LIMIT = 10;
+class DataAdapterCore {
+    constructor(_adapterName, _cacheSuffix) {
+        this._adapterName = _adapterName;
+        this._cacheSuffix = _cacheSuffix;
+        this._errorBoundary = null;
+        this._sdkKey = null;
+        this._inMemoryCache = {};
+        this._lastModifiedStoreKey = `statsig.last_modified_time.${_cacheSuffix}`;
+    }
+    attach(sdkKey, _options) {
+        this._sdkKey = sdkKey;
+        this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey);
+        (0, Monitoring_1.monitorClass)(this._errorBoundary, this);
+    }
+    getDataSync(user) {
+        const cacheKey = this._getCacheKey(user);
+        const result = this._inMemoryCache[cacheKey];
+        if (result) {
+            return result;
+        }
+        const cache = this._loadFromCache(cacheKey);
+        if (cache) {
+            this._addToInMemoryCache(cacheKey, cache);
+            return this._inMemoryCache[cacheKey];
+        }
+        return null;
+    }
+    getDataAsync(current, user) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const cache = current !== null && current !== void 0 ? current : this.getDataSync(user);
+            const latest = yield this._fetchLatest((_a = cache === null || cache === void 0 ? void 0 : cache.data) !== null && _a !== void 0 ? _a : null, user);
+            const cacheKey = this._getCacheKey(user);
+            if (latest) {
+                this._addToInMemoryCache(cacheKey, latest);
+            }
+            if ((latest === null || latest === void 0 ? void 0 : latest.source) === 'Network' ||
+                (latest === null || latest === void 0 ? void 0 : latest.source) === 'NetworkNotModified') {
+                yield this._writeToCache(cacheKey, latest);
+            }
+            return latest;
+        });
+    }
+    prefetchData(user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheKey = this._getCacheKey(user);
+            const result = yield this.getDataAsync(null, user);
+            if (result) {
+                this._addToInMemoryCache(cacheKey, Object.assign(Object.assign({}, result), { source: 'Prefetch' }));
+            }
+        });
+    }
+    setData(data, user) {
+        const cacheKey = this._getCacheKey(user);
+        this._addToInMemoryCache(cacheKey, {
+            source: 'Bootstrap',
+            data,
+            receivedAt: Date.now(),
+        });
+    }
+    /**
+     * (Internal Use Only) - Used by \@statsig/react-native-bindings to prime the cache from AsyncStorage
+     *
+     * @param {Record<string, DataAdapterResult>} cache The values to merge into _inMemoryCache
+     */
+    __primeInMemoryCache(cache) {
+        this._inMemoryCache = Object.assign(Object.assign({}, this._inMemoryCache), cache);
+    }
+    _fetchLatest(current, user) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const latest = yield this._fetchFromNetwork(current, user);
+            if (!latest) {
+                Log_1.Log.debug('No response returned for latest value');
+                return null;
+            }
+            const response = (0, TypedJsonParse_1.typedJsonParse)(latest, 'has_updates', 'Failure while attempting to persist latest value');
+            if (current && (response === null || response === void 0 ? void 0 : response.has_updates) === false) {
+                return {
+                    source: 'NetworkNotModified',
+                    data: current,
+                    receivedAt: Date.now(),
+                };
+            }
+            if ((response === null || response === void 0 ? void 0 : response.has_updates) !== true) {
+                return null;
+            }
+            return { source: 'Network', data: latest, receivedAt: Date.now() };
+        });
+    }
+    _getSdkKey() {
+        if (this._sdkKey != null) {
+            return this._sdkKey;
+        }
+        Log_1.Log.error(`${this._adapterName} is not attached to a Client`);
+        return '';
+    }
+    _getCacheKey(user) {
+        const key = (0, StatsigUser_1.getUserStorageKey)(this._getSdkKey(), user);
+        return `${StatsigDataAdapter_1.DataAdapterCachePrefix}.${this._cacheSuffix}.${key}`;
+    }
+    _addToInMemoryCache(cacheKey, result) {
+        const entries = Object.entries(this._inMemoryCache);
+        if (entries.length < CACHE_LIMIT) {
+            this._inMemoryCache[cacheKey] = result;
+            return;
+        }
+        const [oldest] = entries.reduce((acc, curr) => {
+            return curr[1] < acc[1] ? curr : acc;
+        });
+        delete this._inMemoryCache[oldest];
+        this._inMemoryCache[cacheKey] = result;
+    }
+    _loadFromCache(cacheKey) {
+        var _a;
+        const cache = (_a = StorageProvider_1.Storage.getItemSync) === null || _a === void 0 ? void 0 : _a.call(StorageProvider_1.Storage, cacheKey);
+        if (cache == null) {
+            return null;
+        }
+        const result = (0, TypedJsonParse_1.typedJsonParse)(cache, 'source', 'Failed to parse cached result');
+        return result ? Object.assign(Object.assign({}, result), { source: 'Cache' }) : null;
+    }
+    _writeToCache(cacheKey, result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield StorageProvider_1.Storage.setItem(cacheKey, JSON.stringify(result));
+            yield this._runLocalStorageCacheEviction(cacheKey);
+        });
+    }
+    _runLocalStorageCacheEviction(cacheKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const lastModifiedTimeMap = (_a = (yield (0, StorageProvider_1.getObjectFromStorage)(this._lastModifiedStoreKey))) !== null && _a !== void 0 ? _a : {};
+            lastModifiedTimeMap[cacheKey] = Date.now();
+            const entries = Object.entries(lastModifiedTimeMap);
+            if (entries.length <= CACHE_LIMIT) {
+                yield (0, StorageProvider_1.setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap);
+                return;
+            }
+            const oldest = entries.reduce((acc, current) => {
+                return current[1] < acc[1] ? current : acc;
+            });
+            delete lastModifiedTimeMap[oldest[0]];
+            yield StorageProvider_1.Storage.removeItem(oldest[0]);
+            yield (0, StorageProvider_1.setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap);
+        });
+    }
+}
+exports.DataAdapterCore = DataAdapterCore;

package/src/Diagnostics.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Diagnostics = exports.captureDiagnostics = void 0;
-var Log_1 = require("./Log");
-var SUPPORTS_PERFORMANCE_API = typeof performance !== 'undefined' && typeof performance.mark !== 'undefined';
-var markers = [];
+const Log_1 = require("./Log");
+const SUPPORTS_PERFORMANCE_API = typeof performance !== 'undefined' && typeof performance.mark !== 'undefined';
+let markers = [];
 function captureDiagnostics(func, task) {
-    Diagnostics.mark("".concat(func, ":start"));
-    var result = task();
-    var markEnd = function () {
-        Diagnostics.mark("".concat(func, ":end"));
-        maybeFlush("".concat(func, ":end"));
+    Diagnostics.mark(`${func}:start`);
+    const result = task();
+    const markEnd = () => {
+        Diagnostics.mark(`${func}:end`);
+        maybeFlush(`${func}:end`);
     };
     if (result && result instanceof Promise) {
-        return result.finally(function () { return markEnd(); });
+        return result.finally(() => markEnd());
     }
     else {
         markEnd();
@@ -20,32 +20,27 @@ function captureDiagnostics(func, task) {
     return result;
 }
 exports.captureDiagnostics = captureDiagnostics;
-var Diagnostics = /** @class */ (function () {
-    function Diagnostics() {
-    }
-    Diagnostics.mark = function (tag, metadata) {
+class Diagnostics {
+    static mark(tag, metadata) {
         if (!SUPPORTS_PERFORMANCE_API) {
             return;
         }
-        var marker = performance.mark(tag, { detail: metadata });
+        const marker = performance.mark(tag, { detail: metadata });
         markers.push(marker);
-    };
-    Diagnostics.flush = function () {
-        var resources = performance
+    }
+    static flush() {
+        const resources = performance
             .getEntriesByType('resource')
-            .filter(function (resource) {
-            return resource.name.startsWith('https://api.statsig.com');
-        });
-        var payload = {
-            markers: markers,
-            resources: resources,
+            .filter((resource) => resource.name.startsWith('https://api.statsig.com'));
+        const payload = {
+            markers,
+            resources,
         };
         // TODO: Send as log to Statsig
         Log_1.Log.debug('Diagnostics', payload, JSON.stringify(payload));
         markers = [];
-    };
-    return Diagnostics;
-}());
+    }
+}
 exports.Diagnostics = Diagnostics;
 function maybeFlush(tag) {
     if (tag.startsWith('initialize:')) {

package/src/ErrorBoundary.d.ts

@@ -5,5 +5,6 @@ export declare class ErrorBoundary {
     private _seen;
     constructor(_sdkKey: string);
     capture(tag: string, task: () => unknown, emitter?: StatsigClientEmitEventFunc): unknown;
+    logError(tag: string, error: unknown): void;
     private _onError;
 }

package/src/ErrorBoundary.js

@@ -1,15 +1,4 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
@@ -19,49 +8,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorBoundary = exports.EXCEPTION_ENDPOINT = void 0;
-var Log_1 = require("./Log");
-var StatsigMetadata_1 = require("./StatsigMetadata");
+const Log_1 = require("./Log");
+const StatsigMetadata_1 = require("./StatsigMetadata");
 exports.EXCEPTION_ENDPOINT = 'https://statsigapi.net/v1/sdk_exception';
-var ErrorBoundary = /** @class */ (function () {
-    function ErrorBoundary(_sdkKey) {
+class ErrorBoundary {
+    constructor(_sdkKey) {
         this._sdkKey = _sdkKey;
         this._seen = new Set();
     }
-    ErrorBoundary.prototype.capture = function (tag, task, emitter) {
-        var _this = this;
+    capture(tag, task, emitter) {
         try {
-            var res = task();
+            const res = task();
             if (res && res instanceof Promise) {
-                return res.catch(function (err) { return _this._onError(tag, err, emitter); });
+                return res.catch((err) => this._onError(tag, err, emitter));
             }
             return res;
         }
@@ -69,57 +30,49 @@ var ErrorBoundary = /** @class */ (function () {
             this._onError(tag, error, emitter);
             return null;
         }
-    };
-    ErrorBoundary.prototype._onError = function (tag, error, emitter) {
-        var _this = this;
+    }
+    logError(tag, error) {
+        this._onError(tag, error);
+    }
+    _onError(tag, error, emitter) {
         try {
-            Log_1.Log.warn("Caught error in ".concat(tag), { error: error });
-            var impl = function () { return __awaiter(_this, void 0, void 0, function () {
-                var unwrapped, isError, name, statsigMetadata, info, body;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            unwrapped = (error !== null && error !== void 0 ? error : Error('[Statsig] Error was empty'));
-                            isError = unwrapped instanceof Error;
-                            name = isError ? unwrapped.name : 'No Name';
-                            if (this._seen.has(name)) {
-                                return [2 /*return*/];
-                            }
-                            this._seen.add(name);
-                            statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
-                            info = isError ? unwrapped.stack : _getDescription(unwrapped);
-                            body = JSON.stringify(__assign({ tag: tag, exception: name, info: info }, statsigMetadata));
-                            return [4 /*yield*/, fetch(exports.EXCEPTION_ENDPOINT, {
-                                    method: 'POST',
-                                    headers: {
-                                        'STATSIG-API-KEY': this._sdkKey,
-                                        'STATSIG-SDK-TYPE': String(statsigMetadata.sdkType),
-                                        'STATSIG-SDK-VERSION': String(statsigMetadata.sdkVersion),
-                                        'Content-Type': 'application/json',
-                                    },
-                                    body: body,
-                                })];
-                        case 1:
-                            _a.sent();
-                            emitter === null || emitter === void 0 ? void 0 : emitter({ event: 'error', error: error });
-                            return [2 /*return*/];
-                    }
+            Log_1.Log.warn(`Caught error in ${tag}`, { error });
+            const impl = () => __awaiter(this, void 0, void 0, function* () {
+                const unwrapped = (error !== null && error !== void 0 ? error : Error('[Statsig] Error was empty'));
+                const isError = unwrapped instanceof Error;
+                const name = isError ? unwrapped.name : 'No Name';
+                if (this._seen.has(name)) {
+                    return;
+                }
+                this._seen.add(name);
+                const statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
+                const info = isError ? unwrapped.stack : _getDescription(unwrapped);
+                const body = JSON.stringify(Object.assign({ tag, exception: name, info }, statsigMetadata));
+                yield fetch(exports.EXCEPTION_ENDPOINT, {
+                    method: 'POST',
+                    headers: {
+                        'STATSIG-API-KEY': this._sdkKey,
+                        'STATSIG-SDK-TYPE': String(statsigMetadata.sdkType),
+                        'STATSIG-SDK-VERSION': String(statsigMetadata.sdkVersion),
+                        'Content-Type': 'application/json',
+                    },
+                    body,
                 });
-            }); };
+                emitter === null || emitter === void 0 ? void 0 : emitter({ name: 'error', error });
+            });
             impl()
-                .then(function () {
+                .then(() => {
                 /* noop */
             })
-                .catch(function () {
+                .catch(() => {
                 /* noop */
             });
         }
         catch (_error) {
             /* noop */
         }
-    };
-    return ErrorBoundary;
-}());
+    }
+}
 exports.ErrorBoundary = ErrorBoundary;
 function _getDescription(obj) {
     try {

package/src/EvaluationOptions.d.ts

@@ -0,0 +1,20 @@
+export type EvaluationOptionsCommon = {
+    /**
+     * Prevents an exposure log being created for this check.
+     *
+     * default: `false`
+     */
+    disableExposureLog?: boolean;
+};
+export type FeatureGateEvaluationOptions = EvaluationOptionsCommon & {};
+export type DynamicConfigEvaluationOptions = EvaluationOptionsCommon & {};
+export type ExperimentEvaluationOptions = EvaluationOptionsCommon & {
+    /**
+     * Provide a map of values to be used across checks
+     *
+     * @requires {@link @statsig/js-user-persisted-storage}
+     * @see {@link https://docs.statsig.com/client/concepts/persistent_assignment#example-usage}
+     */
+    userPersistedValues?: unknown;
+};
+export type LayerEvaluationOptions = EvaluationOptionsCommon & {};

package/src/EvaluationTypes.d.ts

@@ -0,0 +1,39 @@
+import { Flatten } from './UtitlityTypes';
+type EvaluationBase<T> = {
+    id_type: string;
+    name: string;
+    rule_id: string;
+    secondary_exposures: SecondaryExposure[];
+    value: T;
+};
+export type SecondaryExposure = {
+    gate: string;
+    gateValue: string;
+    ruleID: string;
+};
+export type GateEvaluation = EvaluationBase<boolean>;
+export type ExperimentEvaluation = Flatten<EvaluationBase<Record<string, unknown>> & {
+    group_name?: string;
+    group: string;
+    id_type: string;
+    is_device_based: boolean;
+    is_experiment_active?: boolean;
+    is_user_in_experiment?: boolean;
+}>;
+export type DynamicConfigEvaluation = ExperimentEvaluation;
+export type LayerEvaluation = Flatten<Omit<ExperimentEvaluation, 'id_type'> & {
+    allocated_experiment_name: string;
+    explicit_parameters: string[];
+    undelegated_secondary_exposures?: SecondaryExposure[];
+}>;
+export type AnyEvaluation = GateEvaluation | ExperimentEvaluation | DynamicConfigEvaluation | LayerEvaluation;
+export type EvaluationDetails = {
+    reason: string;
+    lcut?: number;
+    receivedAt?: number;
+};
+export type DetailedEvaluation<T extends AnyEvaluation> = {
+    evaluation: T | null;
+    details: EvaluationDetails;
+};
+export {};

package/src/EvaluationTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/EventLogger.d.ts

@@ -10,22 +10,35 @@ export declare class EventLogger {
     private _options;
     private _queue;
     private _flushTimer;
-    private _lastExposureMap;
+    private _lastExposureTimeMap;
+    private _nonExposedChecks;
     private _maxQueueSize;
-    private _failedLogs;
+    private _hasRunQuickFlush;
+    private _creationTime;
+    private _isLoggingDisabled;
+    private _logEventUrl;
+    private _logEventBeaconUrl;
     constructor(_sdkKey: string, _emitter: StatsigClientEmitEventFunc, _network: NetworkCore, _options: StatsigOptionsCommon | null);
+    setLoggingDisabled(isDisabled: boolean): void;
     enqueue(event: StatsigEventInternal): void;
+    incrementNonExposureCount(name: string): void;
     reset(): void;
     onVisibilityChanged(visibility: Visibility): void;
     shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    private _quickFlushIfNeeded;
     private _shouldLogEvent;
     private _flushAndForget;
-    private _flush;
     private _sendEvents;
     private _sendEventsViaPost;
     private _sendEventsViaBeacon;
-    private _isBeaconSupported;
     private _saveFailedLogsToStorage;
     private _retryFailedLogs;
     private _getStorageKey;
+    private _normalizeAndAppendEvent;
+    private _appendAndResetNonExposedChecks;
 }