@statsig/client-core 0.0.1-beta.3 → 0.0.1-beta.31

package/src/SafeJs.d.ts

@@ -0,0 +1,4 @@
+export declare const _getWindowSafe: () => Window | null;
+export declare const _getDocumentSafe: () => Document | null;
+export declare const _addWindowEventListenerSafe: (key: string, listener: () => void) => void;
+export declare const _addDocumentEventListenerSafe: (key: string, listener: () => void) => void;

package/src/SafeJs.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._addDocumentEventListenerSafe = exports._addWindowEventListenerSafe = exports._getDocumentSafe = exports._getWindowSafe = void 0;
+const _getWindowSafe = () => {
+    return typeof window !== 'undefined' ? window : null;
+};
+exports._getWindowSafe = _getWindowSafe;
+const _getDocumentSafe = () => {
+    var _a;
+    const win = (0, exports._getWindowSafe)();
+    return (_a = win === null || win === void 0 ? void 0 : win.document) !== null && _a !== void 0 ? _a : null;
+};
+exports._getDocumentSafe = _getDocumentSafe;
+const _addWindowEventListenerSafe = (key, listener) => {
+    const win = (0, exports._getWindowSafe)();
+    if (typeof (win === null || win === void 0 ? void 0 : win.addEventListener) === 'function') {
+        win.addEventListener(key, listener);
+    }
+};
+exports._addWindowEventListenerSafe = _addWindowEventListenerSafe;
+const _addDocumentEventListenerSafe = (key, listener) => {
+    const doc = (0, exports._getDocumentSafe)();
+    if (typeof (doc === null || doc === void 0 ? void 0 : doc.addEventListener) === 'function') {
+        doc.addEventListener(key, listener);
+    }
+};
+exports._addDocumentEventListenerSafe = _addDocumentEventListenerSafe;

package/src/SessionID.d.ts

@@ -1,3 +1,12 @@
+type SessionState = {
+    emitFunction: () => void;
+    ageTimeoutID: ReturnType<typeof setTimeout> | null;
+    idleTimeoutID: ReturnType<typeof setTimeout> | null;
+};
 export declare const SessionID: {
-    get: (sdkKey: string) => string;
+    get: (sdkKey: string) => Promise<string>;
+    _getPromise: (sdkKey: string) => Promise<string>;
+    _setEmitFunction: (eFunction: () => void, sdkKey: string) => void;
+    _resetTimeout: (sessionState: SessionState, timeoutID: ReturnType<typeof setTimeout> | null, duration: number) => ReturnType<typeof setTimeout> | null;
 };
+export {};

package/src/SessionID.js

@@ -1,13 +1,93 @@
 "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.SessionID = void 0;
-var UUID_1 = require("./UUID");
-var SESSION_ID_MAP = {};
+const Hashing_1 = require("./Hashing");
+const Log_1 = require("./Log");
+const StorageProvider_1 = require("./StorageProvider");
+const UUID_1 = require("./UUID");
+const SESSION_ID_MAP = {};
+const SESSION_STATE_MAP = {};
+const PROMISE_MAP = {};
+const MAX_SESSION_IDLE_TIME = 30 * 60 * 1000; // 30 minutes
+const MAX_SESSION_AGE = 4 * 60 * 60 * 1000; // 4 hours
 exports.SessionID = {
-    get: function (sdkKey) {
-        if (SESSION_ID_MAP[sdkKey] == null) {
-            SESSION_ID_MAP[sdkKey] = (0, UUID_1.getUUID)();
+    get: (sdkKey) => {
+        if (PROMISE_MAP[sdkKey] != null) {
+            return PROMISE_MAP[sdkKey];
+        }
+        return (PROMISE_MAP[sdkKey] = exports.SessionID._getPromise(sdkKey));
+    },
+    _getPromise: (sdkKey) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        let session = SESSION_ID_MAP[sdkKey];
+        const now = Date.now();
+        if (session == null) {
+            let tempSession = yield _loadFromStorage(sdkKey);
+            if (tempSession == null) {
+                tempSession = {
+                    sessionID: (0, UUID_1.getUUID)(),
+                    startTime: now,
+                    lastUpdate: now,
+                };
+            }
+            session = tempSession;
+            SESSION_ID_MAP[sdkKey] = session;
         }
-        return SESSION_ID_MAP[sdkKey];
+        const sessionState = (_a = SESSION_STATE_MAP[sdkKey]) !== null && _a !== void 0 ? _a : {
+            ageTimeoutID: null,
+            idleTimeoutID: null,
+            emitFunction: () => {
+                return;
+            },
+        };
+        if (now - session.startTime > MAX_SESSION_AGE ||
+            now - session.lastUpdate > MAX_SESSION_IDLE_TIME) {
+            session.sessionID = (0, UUID_1.getUUID)();
+            session.startTime = now;
+        }
+        session.lastUpdate = now;
+        _persistToStorage(session, sdkKey);
+        sessionState.idleTimeoutID = exports.SessionID._resetTimeout(sessionState, sessionState.idleTimeoutID, MAX_SESSION_IDLE_TIME);
+        sessionState.ageTimeoutID = exports.SessionID._resetTimeout(sessionState, sessionState.ageTimeoutID, MAX_SESSION_AGE - (now - session.startTime));
+        SESSION_ID_MAP[sdkKey] = session;
+        SESSION_STATE_MAP[sdkKey] = sessionState;
+        PROMISE_MAP[sdkKey] = null;
+        return session.sessionID;
+    }),
+    _setEmitFunction: (eFunction, sdkKey) => {
+        var _a;
+        const sessionState = (_a = SESSION_STATE_MAP[sdkKey]) !== null && _a !== void 0 ? _a : {
+            ageTimeoutID: null,
+            idleTimeoutID: null,
+            emitFunction: eFunction,
+        };
+        sessionState.emitFunction = eFunction;
+        SESSION_STATE_MAP[sdkKey] = sessionState;
+    },
+    _resetTimeout: (sessionState, timeoutID, duration) => {
+        clearTimeout(timeoutID !== null && timeoutID !== void 0 ? timeoutID : undefined);
+        return setTimeout(sessionState.emitFunction, duration);
     },
 };
+function _getSessionIDStorageKey(sdkKey) {
+    return `statsig.session_id.${(0, Hashing_1.DJB2)(sdkKey)}`;
+}
+function _persistToStorage(session, sdkKey) {
+    const storageKey = _getSessionIDStorageKey(sdkKey);
+    (0, StorageProvider_1._setObjectInStorage)(storageKey, session).catch(() => {
+        Log_1.Log.warn('Failed to save SessionID');
+    });
+}
+function _loadFromStorage(sdkKey) {
+    const storageKey = _getSessionIDStorageKey(sdkKey);
+    return (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+}

package/src/StableID.js

@@ -8,71 +8,42 @@ 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.StableID = void 0;
-var Hashing_1 = require("./Hashing");
-var Log_1 = require("./Log");
-var StorageProvider_1 = require("./StorageProvider");
-var UUID_1 = require("./UUID");
-var PROMISE_MAP = {};
+const Hashing_1 = require("./Hashing");
+const Log_1 = require("./Log");
+const StorageProvider_1 = require("./StorageProvider");
+const UUID_1 = require("./UUID");
+const PROMISE_MAP = {};
 exports.StableID = {
-    get: function (sdkKey) { return __awaiter(void 0, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            if (PROMISE_MAP[sdkKey] == null) {
-                PROMISE_MAP[sdkKey] = _loadFromStorage(sdkKey).then(function (stableID) {
-                    if (stableID != null) {
-                        return stableID;
-                    }
-                    var newStableID = (0, UUID_1.getUUID)();
-                    _persistToStorage(newStableID, sdkKey);
-                    return newStableID;
-                });
-            }
-            return [2 /*return*/, PROMISE_MAP[sdkKey]];
-        });
-    }); },
-    setOverride: function (override, sdkKey) {
+    get: (sdkKey) => __awaiter(void 0, void 0, void 0, function* () {
+        if (PROMISE_MAP[sdkKey] == null) {
+            PROMISE_MAP[sdkKey] = _loadFromStorage(sdkKey).then((stableID) => {
+                if (stableID != null) {
+                    return stableID;
+                }
+                const newStableID = (0, UUID_1.getUUID)();
+                _persistToStorage(newStableID, sdkKey);
+                return newStableID;
+            });
+        }
+        return PROMISE_MAP[sdkKey];
+    }),
+    setOverride: (override, sdkKey) => {
         PROMISE_MAP[sdkKey] = Promise.resolve(override);
         _persistToStorage(override, sdkKey);
     },
 };
 function _getStableIDStorageKey(sdkKey) {
-    return "statsig.stable_id:".concat((0, Hashing_1.DJB2)(sdkKey));
+    return `statsig.stable_id.${(0, Hashing_1.DJB2)(sdkKey)}`;
 }
 function _persistToStorage(stableID, sdkKey) {
-    var storageKey = _getStableIDStorageKey(sdkKey);
-    (0, StorageProvider_1.setObjectInStorage)(storageKey, stableID).catch(function () {
+    const storageKey = _getStableIDStorageKey(sdkKey);
+    (0, StorageProvider_1._setObjectInStorage)(storageKey, stableID).catch(() => {
         Log_1.Log.warn('Failed to save StableID');
     });
 }
 function _loadFromStorage(sdkKey) {
-    var storageKey = _getStableIDStorageKey(sdkKey);
-    return (0, StorageProvider_1.getObjectFromStorage)(storageKey);
+    const storageKey = _getStableIDStorageKey(sdkKey);
+    return (0, StorageProvider_1._getObjectFromStorage)(storageKey);
 }

package/src/StatsigClientBase.d.ts

@@ -1,37 +1,66 @@
 import './$_StatsigGlobal';
 import { ErrorBoundary } from './ErrorBoundary';
+import { EvaluationOptionsCommon } from './EvaluationOptions';
 import { EventLogger } from './EventLogger';
 import { NetworkCore } from './NetworkCore';
-import { StatsigClientEvent, StatsigClientEventCallback, StatsigClientEventData, StatsigClientEventEmitterInterface, StatsigLoadingStatus } from './StatsigClientEventEmitter';
-import { DataSource, StatsigDataProvider } from './StatsigDataProvider';
+import { OverrideAdapter } from './OverrideAdapter';
+import { AnyStatsigClientEvent, StatsigClientEventCallback, StatsigClientEventEmitterInterface, StatsigClientEventName, StatsigLoadingStatus } from './StatsigClientEventEmitter';
+import { DataAdapterResult, EvaluationsDataAdapter, SpecsDataAdapter } from './StatsigDataAdapter';
 import { StatsigEventInternal } from './StatsigEvent';
-import { StatsigOptionsCommon } from './StatsigOptionsCommon';
-import { StatsigUser } from './StatsigUser';
-type DataProviderResult = {
-    data: string | null;
-    source: DataSource;
+import { AnyStatsigOptions, StatsigRuntimeMutableOptions } from './StatsigOptionsCommon';
+export type StatsigClientEmitEventFunc = (event: AnyStatsigClientEvent) => void;
+export type StatsigContext = {
+    sdkKey: string;
+    options: AnyStatsigOptions;
+    sessionID: string;
+    values: unknown;
 };
-export type EvaluationOptions = {
-    disableExposureLog?: boolean;
-};
-export declare const DEFAULT_EVAL_OPTIONS: EvaluationOptions;
-export type StatsigClientEmitEventFunc = (data: StatsigClientEventData) => void;
-export declare class StatsigClientBase implements StatsigClientEventEmitterInterface {
+export declare abstract class StatsigClientBase<TAdapter extends EvaluationsDataAdapter | SpecsDataAdapter> implements StatsigClientEventEmitterInterface {
     loadingStatus: StatsigLoadingStatus;
-    protected _errorBoundary: ErrorBoundary;
-    protected _logger: EventLogger;
-    protected _sdkKey: string;
-    protected _dataProviders: StatsigDataProvider[];
+    readonly dataAdapter: TAdapter;
+    protected readonly _sdkKey: string;
+    protected readonly _options: AnyStatsigOptions;
+    protected readonly _errorBoundary: ErrorBoundary;
+    protected readonly _logger: EventLogger;
+    protected readonly _overrideAdapter: OverrideAdapter | null;
     private _listeners;
-    constructor(sdkKey: string, network: NetworkCore, options: StatsigOptionsCommon | null, dataProviders: StatsigDataProvider[]);
-    on(event: StatsigClientEvent | '*', listener: StatsigClientEventCallback): void;
-    off(event: StatsigClientEvent | '*', listener: StatsigClientEventCallback): void;
-    protected emit(data: StatsigClientEventData): void;
-    protected _setStatus(newStatus: StatsigLoadingStatus): void;
-    protected _getDataFromProviders(user?: StatsigUser): DataProviderResult;
-    protected _getDataFromProvidersAsync(user?: StatsigUser): Promise<DataProviderResult>;
-    protected _getDataPostInitFromProviders(currentData: string | null, user?: StatsigUser): Promise<DataProviderResult>;
-    protected _saveToDataProviders(currentData: string | null, user?: StatsigUser): void;
-    protected _enqueueExposure(options: EvaluationOptions, exposure: StatsigEventInternal): void;
+    constructor(sdkKey: string, adapter: TAdapter, network: NetworkCore, options: AnyStatsigOptions | null);
+    /**
+     * Updates runtime configuration options for the SDK, allowing toggling of certain behaviors such as logging and storage to comply with user preferences or regulations such as GDPR.
+     *
+     * @param {StatsigRuntimeMutableOptions} options - The configuration options that dictate the runtime behavior of the SDK.
+     */
+    updateRuntimeOptions(options: StatsigRuntimeMutableOptions): void;
+    /**
+     * Flushes any currently queued events.
+     */
+    flush(): Promise<void>;
+    /**
+     * Gracefully shuts down the SDK, ensuring that all pending events are send before the SDK stops.
+     * This function emits a 'pre_shutdown' event and then waits for the logger to complete its shutdown process.
+     *
+     * @returns {Promise<void>} A promise that resolves when all shutdown procedures, including logging shutdown, have been completed.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Subscribes a callback function to a specific {@link StatsigClientEvent} or all StatsigClientEvents if the wildcard '*' is used.
+     * Once subscribed, the listener callback will be invoked whenever the specified event is emitted.
+     *
+     * @param {StatsigClientEventName} event - The name of the event to subscribe to, or '*' to subscribe to all events.
+     * @param {StatsigClientEventCallback<T>} listener - The callback function to execute when the event occurs. The function receives event-specific data as its parameter.
+     * @see {@link off} for unsubscribing from events.
+     */
+    on<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    /**
+     * Unsubscribes a previously registered callback function from a specific {@link StatsigClientEvent} or all StatsigClientEvents if the wildcard '*' is used.
+     *
+     * @param {StatsigClientEventName} event - The name of the event from which to unsubscribe, or '*' to unsubscribe from all events.
+     * @param {StatsigClientEventCallback<T>} listener - The callback function to remove from the event's notification list.
+     * @see {@link on} for subscribing to events.
+     */
+    off<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    __on<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    protected _emit(event: AnyStatsigClientEvent): void;
+    protected _setStatus(newStatus: StatsigLoadingStatus, values: DataAdapterResult | null): void;
+    protected _enqueueExposure(name: string, exposure: StatsigEventInternal, options?: EvaluationOptionsCommon): void;
 }
-export {};