@statsig/client-core 0.0.1-beta.9 → 1.0.1

package/package.json

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

package/src/$_StatsigGlobal.d.ts

@@ -1,6 +1,11 @@
+import { StatsigClientInterface } from './ClientInterfaces';
 export type StatsigGlobal = {
     [key: string]: unknown;
-    instances?: Set<unknown>;
+    instances?: Record<string, StatsigClientInterface>;
+    lastInstance?: StatsigClientInterface;
+    acInstances?: Record<string, unknown>;
+    srInstances?: Record<string, unknown>;
+    instance: (sdkKey?: string) => StatsigClientInterface | undefined;
 };
 declare global {
     let __STATSIG__: StatsigGlobal | undefined;
@@ -8,3 +13,6 @@ declare global {
         __STATSIG__: StatsigGlobal | undefined;
     }
 }
+export declare const _getStatsigGlobal: () => StatsigGlobal;
+export declare const _getStatsigGlobalFlag: (flag: string) => unknown;
+export declare const _getInstance: (sdkKey: string) => StatsigClientInterface | undefined;

package/src/$_StatsigGlobal.js

@@ -1,14 +1,31 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+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;
-}
+exports._getInstance = exports._getStatsigGlobalFlag = exports._getStatsigGlobal = void 0;
+const _getStatsigGlobal = () => {
+    return __STATSIG__ ? __STATSIG__ : statsigGlobal;
+};
+exports._getStatsigGlobal = _getStatsigGlobal;
+const _getStatsigGlobalFlag = (flag) => {
+    return (0, exports._getStatsigGlobal)()[flag];
+};
+exports._getStatsigGlobalFlag = _getStatsigGlobalFlag;
+const _getInstance = (sdkKey) => {
+    const gbl = (0, exports._getStatsigGlobal)();
+    if (!sdkKey) {
+        return gbl.lastInstance;
+    }
+    return gbl.instances && gbl.instances[sdkKey];
+};
+exports._getInstance = _getInstance;
+const GLOBAL_KEY = '__STATSIG__';
+const _window = typeof window !== 'undefined' ? window : {};
+const _global = typeof global !== 'undefined' ? global : {};
+const _globalThis = typeof globalThis !== 'undefined' ? globalThis : {};
+const statsigGlobal = (_c = (_b = (_a = _window[GLOBAL_KEY]) !== null && _a !== void 0 ? _a : _global[GLOBAL_KEY]) !== null && _b !== void 0 ? _b : _globalThis[GLOBAL_KEY]) !== null && _c !== void 0 ? _c : {
+    instance: exports._getInstance,
+};
+_window[GLOBAL_KEY] = statsigGlobal;
+_global[GLOBAL_KEY] = statsigGlobal;
+_globalThis[GLOBAL_KEY] = statsigGlobal;

package/src/CacheKey.d.ts

@@ -0,0 +1,4 @@
+import { StatsigUser } from './StatsigUser';
+export type CustomCacheKeyGenerator = (sdkKey: string, user: StatsigUser) => string;
+export declare function _getUserStorageKey(sdkKey: string, user: StatsigUser, customKeyGenerator?: CustomCacheKeyGenerator): string;
+export declare function _getStorageKey(sdkKey: string, user?: StatsigUser, customKeyGenerator?: CustomCacheKeyGenerator): string;

package/src/CacheKey.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getStorageKey = exports._getUserStorageKey = void 0;
+const Hashing_1 = require("./Hashing");
+function _getUserStorageKey(sdkKey, user, customKeyGenerator) {
+    var _a;
+    if (customKeyGenerator) {
+        return customKeyGenerator(sdkKey, user);
+    }
+    const cids = user && user.customIDs ? user.customIDs : {};
+    const parts = [
+        `uid:${(_a = user === null || user === void 0 ? void 0 : user.userID) !== null && _a !== void 0 ? _a : ''}`,
+        `cids:${Object.keys(cids)
+            .sort((leftKey, rightKey) => leftKey.localeCompare(rightKey))
+            .map((key) => `${key}-${cids[key]}`)
+            .join(',')}`,
+        `k:${sdkKey}`,
+    ];
+    return (0, Hashing_1._DJB2)(parts.join('|'));
+}
+exports._getUserStorageKey = _getUserStorageKey;
+function _getStorageKey(sdkKey, user, customKeyGenerator) {
+    if (user) {
+        return _getUserStorageKey(sdkKey, user, customKeyGenerator);
+    }
+    return (0, Hashing_1._DJB2)(`k:${sdkKey}`);
+}
+exports._getStorageKey = _getStorageKey;

package/src/ClientInterfaces.d.ts

@@ -1,30 +1,64 @@
-import { EvaluationOptions } from './StatsigClientBase';
+import { DownloadConfigSpecsResponse } from './DownloadConfigSpecsResponse';
+import { ErrorBoundary } from './ErrorBoundary';
+import { DynamicConfigEvaluationOptions, ExperimentEvaluationOptions, FeatureGateEvaluationOptions, LayerEvaluationOptions } from './EvaluationOptions';
+import { InitializeResponseWithUpdates } from './InitializeResponse';
+import { StatsigSession } from './SessionID';
 import { StatsigClientEventEmitterInterface } from './StatsigClientEventEmitter';
+import { EvaluationsDataAdapter, SpecsDataAdapter } from './StatsigDataAdapter';
 import { StatsigEvent } from './StatsigEvent';
+import { AnyStatsigOptions, StatsigRuntimeMutableOptions } from './StatsigOptionsCommon';
 import { DynamicConfig, Experiment, FeatureGate, Layer } from './StatsigTypes';
 import { StatsigUser } from './StatsigUser';
+import { Flatten } from './UtitlityTypes';
 export interface StatsigClientCommonInterface extends StatsigClientEventEmitterInterface {
     initializeSync(): void;
     initializeAsync(): Promise<void>;
     shutdown(): Promise<void>;
+    flush(): Promise<void>;
+    updateRuntimeOptions(options: StatsigRuntimeMutableOptions): void;
 }
+export type CommonContext = {
+    sdkKey: string;
+    options: AnyStatsigOptions;
+    errorBoundary: ErrorBoundary;
+};
+export type AsyncCommonContext = {
+    session: StatsigSession;
+    stableID: string;
+};
+export type OnDeviceEvaluationsContext = CommonContext & {
+    values: DownloadConfigSpecsResponse | null;
+};
+export type OnDeviceEvaluationsAsyncContext = OnDeviceEvaluationsContext & AsyncCommonContext;
 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;
+    getAsyncContext(): Promise<OnDeviceEvaluationsAsyncContext>;
+    getContext(): OnDeviceEvaluationsContext;
+    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;
+    logEvent(eventName: string, user: StatsigUser, value?: string | number, metadata?: Record<string, string>): void;
 }
+export type PrecomputedEvaluationsContext = Flatten<CommonContext & {
+    values: InitializeResponseWithUpdates | null;
+    user: StatsigUser;
+}>;
+export type PrecomputedEvaluationsAsyncContext = Flatten<AsyncCommonContext & PrecomputedEvaluationsContext>;
 export interface PrecomputedEvaluationsInterface extends StatsigClientCommonInterface {
-    getCurrentUser(): StatsigUser;
+    readonly dataAdapter: EvaluationsDataAdapter;
+    getAsyncContext(): Promise<PrecomputedEvaluationsAsyncContext>;
+    getContext(): PrecomputedEvaluationsContext;
     updateUserSync(user: StatsigUser): void;
     updateUserAsync(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;
+    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;
+    logEvent(eventName: string, value?: string | number, metadata?: Record<string, string>): void;
 }
 export type StatsigClientInterface = OnDeviceEvaluationsInterface | PrecomputedEvaluationsInterface;

package/src/DataAdapterCore.d.ts

@@ -0,0 +1,31 @@
+import { DataAdapterAsyncOptions, DataAdapterResult } from './StatsigDataAdapter';
+import { AnyStatsigOptions } from './StatsigOptionsCommon';
+import { StatsigUser } from './StatsigUser';
+export declare abstract class DataAdapterCore {
+    private _adapterName;
+    protected _cacheSuffix: string;
+    protected _options: AnyStatsigOptions | null;
+    private _sdkKey;
+    private _inMemoryCache;
+    private _lastModifiedStoreKey;
+    protected constructor(_adapterName: string, _cacheSuffix: string);
+    attach(sdkKey: string, options: AnyStatsigOptions | null): void;
+    getDataSync(user?: StatsigUser | undefined): DataAdapterResult | null;
+    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 _getDataAsyncImpl(current: DataAdapterResult | null, user?: StatsigUser, options?: DataAdapterAsyncOptions): Promise<DataAdapterResult | null>;
+    protected _prefetchDataImpl(user?: StatsigUser, options?: DataAdapterAsyncOptions): Promise<void>;
+    protected abstract _fetchFromNetwork(current: string | null, user?: StatsigUser, options?: DataAdapterAsyncOptions): Promise<string | null>;
+    protected abstract _getCacheKey(user?: StatsigUser): string;
+    protected abstract _isCachedResultValidFor204(result: DataAdapterResult, user: StatsigUser | undefined): boolean;
+    private _fetchAndPrepFromNetwork;
+    protected _getSdkKey(): string;
+    private _loadFromCache;
+    private _writeToCache;
+    private _runLocalStorageCacheEviction;
+}

package/src/DataAdapterCore.js

@@ -0,0 +1,196 @@
+"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 Log_1 = require("./Log");
+const StableID_1 = require("./StableID");
+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._options = null;
+        this._sdkKey = null;
+        this._lastModifiedStoreKey = `statsig.last_modified_time.${_cacheSuffix}`;
+        this._inMemoryCache = new InMemoryCache();
+    }
+    attach(sdkKey, options) {
+        this._sdkKey = sdkKey;
+        this._options = options;
+    }
+    getDataSync(user) {
+        const cacheKey = this._getCacheKey(user);
+        const inMem = this._inMemoryCache.get(cacheKey, user);
+        if (inMem) {
+            return inMem;
+        }
+        const cache = this._loadFromCache(cacheKey);
+        if (cache) {
+            this._inMemoryCache.add(cacheKey, cache);
+            return this._inMemoryCache.get(cacheKey, user);
+        }
+        return null;
+    }
+    setData(data, user) {
+        var _a;
+        const normalized = user && (0, StatsigUser_1._normalizeUser)(user, (_a = this._options) === null || _a === void 0 ? void 0 : _a.environment);
+        const cacheKey = this._getCacheKey(normalized);
+        this._inMemoryCache.add(cacheKey, _makeDataAdapterResult('Bootstrap', data, null, normalized));
+    }
+    /**
+     * (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.merge(cache);
+    }
+    _getDataAsyncImpl(current, user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cache = current !== null && current !== void 0 ? current : this.getDataSync(user);
+            const ops = [this._fetchAndPrepFromNetwork(cache, user, options)];
+            if (options === null || options === void 0 ? void 0 : options.timeoutMs) {
+                ops.push(new Promise((r) => setTimeout(r, options.timeoutMs)).then(() => {
+                    Log_1.Log.debug('Fetching latest value timed out');
+                    return null;
+                }));
+            }
+            return yield Promise.race(ops);
+        });
+    }
+    _prefetchDataImpl(user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cacheKey = this._getCacheKey(user);
+            const result = yield this._getDataAsyncImpl(null, user, options);
+            if (result) {
+                this._inMemoryCache.add(cacheKey, Object.assign(Object.assign({}, result), { source: 'Prefetch' }));
+            }
+        });
+    }
+    _fetchAndPrepFromNetwork(cachedResult, user, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cachedData = null;
+            if (cachedResult && this._isCachedResultValidFor204(cachedResult, user)) {
+                cachedData = cachedResult.data;
+            }
+            const latest = yield this._fetchFromNetwork(cachedData, user, options);
+            if (!latest) {
+                Log_1.Log.debug('No response returned for latest value');
+                return null;
+            }
+            const response = (0, TypedJsonParse_1._typedJsonParse)(latest, 'has_updates', 'Response');
+            const sdkKey = this._getSdkKey();
+            const stableID = yield StableID_1.StableID.get(sdkKey);
+            let result = null;
+            if ((response === null || response === void 0 ? void 0 : response.has_updates) === true) {
+                result = _makeDataAdapterResult('Network', latest, stableID, user);
+            }
+            else if (cachedData && (response === null || response === void 0 ? void 0 : response.has_updates) === false) {
+                result = _makeDataAdapterResult('NetworkNotModified', cachedData, stableID, user);
+            }
+            else {
+                return null;
+            }
+            const cacheKey = this._getCacheKey(user);
+            this._inMemoryCache.add(cacheKey, result);
+            yield this._writeToCache(cacheKey, result);
+            return result;
+        });
+    }
+    _getSdkKey() {
+        if (this._sdkKey != null) {
+            return this._sdkKey;
+        }
+        Log_1.Log.error(`${this._adapterName} is not attached to a Client`);
+        return '';
+    }
+    _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', '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 evictable = _getEvictableKey(lastModifiedTimeMap, CACHE_LIMIT);
+            if (evictable) {
+                delete lastModifiedTimeMap[evictable];
+                yield StorageProvider_1.Storage._removeItem(evictable);
+            }
+            yield (0, StorageProvider_1._setObjectInStorage)(this._lastModifiedStoreKey, lastModifiedTimeMap);
+        });
+    }
+}
+exports.DataAdapterCore = DataAdapterCore;
+function _makeDataAdapterResult(source, data, stableID, user) {
+    return {
+        source,
+        data,
+        receivedAt: Date.now(),
+        stableID,
+        fullUserHash: (0, StatsigUser_1._getFullUserHash)(user),
+    };
+}
+class InMemoryCache {
+    constructor() {
+        this._data = {};
+    }
+    get(cacheKey, user) {
+        var _a;
+        const result = this._data[cacheKey];
+        const cached = result === null || result === void 0 ? void 0 : result.stableID;
+        const provided = (_a = user === null || user === void 0 ? void 0 : user.customIDs) === null || _a === void 0 ? void 0 : _a.stableID;
+        if (provided && cached && provided !== cached) {
+            Log_1.Log.warn("'StatsigUser.customIDs.stableID' mismatch");
+            return null;
+        }
+        return result;
+    }
+    add(cacheKey, value) {
+        const oldest = _getEvictableKey(this._data, CACHE_LIMIT - 1);
+        if (oldest) {
+            delete this._data[oldest];
+        }
+        this._data[cacheKey] = value;
+    }
+    merge(values) {
+        this._data = Object.assign(Object.assign({}, this._data), values);
+    }
+}
+function _getEvictableKey(data, limit) {
+    const keys = Object.keys(data);
+    if (keys.length <= limit) {
+        return null;
+    }
+    return keys.reduce((prevKey, currKey) => {
+        const prev = data[prevKey];
+        const current = data[currKey];
+        if (typeof prev === 'object' && typeof current === 'object') {
+            return current.receivedAt < prev.receivedAt ? currKey : prevKey;
+        }
+        return current < prev ? currKey : prevKey;
+    });
+}

package/src/Diagnostics.d.ts

@@ -1,5 +1,3 @@
-export declare function captureDiagnostics(func: string, task: () => unknown): unknown;
 export declare abstract class Diagnostics {
-    static mark(tag: string, metadata?: Record<string, unknown>): void;
-    static flush(): void;
+    static mark(): void;
 }

package/src/Diagnostics.js

@@ -1,54 +1,9 @@
 "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 = [];
-function captureDiagnostics(func, task) {
-    Diagnostics.mark("".concat(func, ":start"));
-    var result = task();
-    var markEnd = function () {
-        Diagnostics.mark("".concat(func, ":end"));
-        maybeFlush("".concat(func, ":end"));
-    };
-    if (result && result instanceof Promise) {
-        return result.finally(function () { return markEnd(); });
+exports.Diagnostics = void 0;
+class Diagnostics {
+    static mark() {
+        //
     }
-    else {
-        markEnd();
-    }
-    return result;
 }
-exports.captureDiagnostics = captureDiagnostics;
-var Diagnostics = /** @class */ (function () {
-    function Diagnostics() {
-    }
-    Diagnostics.mark = function (tag, metadata) {
-        if (!SUPPORTS_PERFORMANCE_API) {
-            return;
-        }
-        var marker = performance.mark(tag, { detail: metadata });
-        markers.push(marker);
-    };
-    Diagnostics.flush = function () {
-        var resources = performance
-            .getEntriesByType('resource')
-            .filter(function (resource) {
-            return resource.name.startsWith('https://api.statsig.com');
-        });
-        var payload = {
-            markers: markers,
-            resources: 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:')) {
-        Diagnostics.flush();
-    }
-}

package/src/DownloadConfigSpecsResponse.d.ts

@@ -0,0 +1,41 @@
+export type SpecCondition = {
+    type: string;
+    targetValue: unknown;
+    operator: string | null;
+    field: string | null;
+    additionalValues: Record<string, unknown> | null;
+    idType: string;
+};
+export type SpecRule = {
+    name: string;
+    passPercentage: number;
+    conditions: SpecCondition[];
+    returnValue: unknown;
+    id: string;
+    salt: string;
+    idType: string;
+    configDelegate: string | null;
+    isExperimentGroup?: boolean;
+    groupName?: string;
+};
+export type Spec = {
+    name: string;
+    type: string;
+    salt: string;
+    defaultValue: unknown;
+    enabled: boolean;
+    idType: string;
+    rules: SpecRule[];
+    entity: string;
+    explicitParameters: string[] | null;
+    hasSharedParams: boolean;
+    isActive?: boolean;
+    targetAppIDs?: string[];
+};
+export type DownloadConfigSpecsResponse = {
+    feature_gates: Spec[];
+    dynamic_configs: Spec[];
+    layer_configs: Spec[];
+    time: number;
+    has_updates: boolean;
+};

package/src/DownloadConfigSpecsResponse.js

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

package/src/ErrorBoundary.d.ts

@@ -1,9 +1,14 @@
 import { StatsigClientEmitEventFunc } from './StatsigClientBase';
+import { AnyStatsigOptions } from './StatsigOptionsCommon';
 export declare const EXCEPTION_ENDPOINT = "https://statsigapi.net/v1/sdk_exception";
 export declare class ErrorBoundary {
     private _sdkKey;
+    private _options;
+    private _emitter?;
     private _seen;
-    constructor(_sdkKey: string);
-    capture(tag: string, task: () => unknown, emitter?: StatsigClientEmitEventFunc): unknown;
+    constructor(_sdkKey: string, _options: AnyStatsigOptions | null, _emitter?: StatsigClientEmitEventFunc | undefined);
+    wrap(instance: unknown): void;
+    logError(tag: string, error: unknown): void;
+    private _capture;
     private _onError;
 }