@statsig/client-core 0.0.1-beta.1

package/src/Log.js

@@ -0,0 +1,59 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.LogLevel = void 0;
+function addTag(args) {
+    args.unshift('[Statsig]');
+    return args; // ['[Statsig]', ...args];
+}
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["None"] = 0] = "None";
+    LogLevel[LogLevel["Error"] = 1] = "Error";
+    LogLevel[LogLevel["Warn"] = 2] = "Warn";
+    LogLevel[LogLevel["Info"] = 3] = "Info";
+    LogLevel[LogLevel["Debug"] = 4] = "Debug";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+var Log = /** @class */ (function () {
+    function Log() {
+    }
+    Log.info = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.level >= LogLevel.Info) {
+            console.info.apply(console, addTag(args));
+        }
+    };
+    Log.debug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.level >= LogLevel.Debug) {
+            console.debug.apply(console, addTag(args));
+        }
+    };
+    Log.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.level >= LogLevel.Warn) {
+            console.warn.apply(console, addTag(args));
+        }
+    };
+    Log.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.level >= LogLevel.Error) {
+            console.error.apply(console, addTag(args));
+        }
+    };
+    Log.level = LogLevel.Error;
+    return Log;
+}());
+exports.Log = Log;

package/src/Monitoring.d.ts

@@ -0,0 +1,3 @@
+import { ErrorBoundary } from './ErrorBoundary';
+export declare function monitorClass<T extends new (...args: any[]) => any>(errorBoundary: ErrorBoundary, target: T, instance: unknown): void;
+export declare function monitorFunction<T>(errorBoundary: ErrorBoundary, tag: string, func: () => T, instance: unknown): T;

package/src/Monitoring.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monitorFunction = exports.monitorClass = void 0;
+var Diagnostics_1 = require("./Diagnostics");
+var StatsigClientBase_1 = require("./StatsigClientBase");
+function monitorClass(errorBoundary, target, instance) {
+    var methods = Object.getOwnPropertyNames(target.prototype);
+    var obj = instance;
+    var _loop_1 = function (method) {
+        if (method === 'constructor' || typeof obj[method] !== 'function') {
+            return "continue";
+        }
+        var original = obj[method];
+        obj[method] = function () {
+            var _this = this;
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            return monitorFunction(errorBoundary, method, function () { return original.apply(_this, args); }, instance);
+        };
+    };
+    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {
+        var method = methods_1[_i];
+        _loop_1(method);
+    }
+}
+exports.monitorClass = monitorClass;
+function monitorFunction(errorBoundary, tag, func, instance) {
+    var client = instance instanceof StatsigClientBase_1.StatsigClientBase ? instance['emit'] : undefined;
+    return errorBoundary.capture(tag, function () { return (0, Diagnostics_1.captureDiagnostics)(tag, function () { return func.apply(instance); }); }, client);
+}
+exports.monitorFunction = monitorFunction;

package/src/NetworkCore.d.ts

@@ -0,0 +1,22 @@
+import { StatsigOptionsCommon } from './StatsigOptionsCommon';
+type RequestArgs = {
+    sdkKey: string;
+    url: string;
+    timeoutMs?: number;
+    retries?: number;
+    headers?: Record<string, string>;
+};
+type RequestArgsWithData = RequestArgs & {
+    data: Record<string, unknown>;
+};
+export declare class NetworkCore {
+    private _options;
+    private readonly _timeout;
+    constructor(_options: StatsigOptionsCommon | null);
+    post(args: RequestArgsWithData): Promise<string | null>;
+    get(args: RequestArgs): Promise<string | null>;
+    beacon(args: RequestArgsWithData): boolean;
+    private _sendRequest;
+    private _getPopulatedURL;
+}
+export {};

package/src/NetworkCore.js

@@ -0,0 +1,197 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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) {
+        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());
+    });
+};
+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.NetworkCore = void 0;
+var Diagnostics_1 = require("./Diagnostics");
+var Log_1 = require("./Log");
+var SessionID_1 = require("./SessionID");
+var StableID_1 = require("./StableID");
+var StatsigMetadata_1 = require("./StatsigMetadata");
+var DEFAULT_TIMEOUT_MS = 10000;
+var NetworkError = /** @class */ (function (_super) {
+    __extends(NetworkError, _super);
+    function NetworkError(message, errorDescription) {
+        var _this = _super.call(this, message) || this;
+        _this.errorDescription = errorDescription;
+        return _this;
+    }
+    return NetworkError;
+}(Error));
+var NetworkCore = /** @class */ (function () {
+    function NetworkCore(_options) {
+        var _a;
+        this._options = _options;
+        this._timeout = (_a = _options === null || _options === void 0 ? void 0 : _options.networkTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_TIMEOUT_MS;
+    }
+    NetworkCore.prototype.post = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, stableID, sessionID, body;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        data = args.data;
+                        return [4 /*yield*/, StableID_1.StableID.get(args.sdkKey)];
+                    case 1:
+                        stableID = _a.sent();
+                        sessionID = SessionID_1.SessionID.get(args.sdkKey);
+                        body = JSON.stringify(__assign(__assign({}, data), { statsigMetadata: __assign(__assign({}, StatsigMetadata_1.StatsigMetadataProvider.get()), { stableID: stableID, sessionID: sessionID }) }));
+                        return [2 /*return*/, this._sendRequest(__assign({ method: 'POST', body: body }, args))];
+                }
+            });
+        });
+    };
+    NetworkCore.prototype.get = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this._sendRequest(__assign({ method: 'GET' }, args))];
+            });
+        });
+    };
+    NetworkCore.prototype.beacon = function (args) {
+        var url = new URL(args.url);
+        url.searchParams.append('k', args.sdkKey);
+        return navigator.sendBeacon(url, JSON.stringify(args.data));
+    };
+    NetworkCore.prototype._sendRequest = function (args) {
+        return __awaiter(this, void 0, void 0, function () {
+            var method, body, retries, controller, handle, response, fullUrl, text, error_1, errorMessage;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        method = args.method, body = args.body, retries = args.retries;
+                        controller = new AbortController();
+                        handle = setTimeout(function () { return controller.abort("Timeout of ".concat(_this._timeout, "ms expired.")); }, this._timeout);
+                        response = null;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        fullUrl = this._getPopulatedURL(args);
+                        return [4 /*yield*/, fetch(fullUrl, {
+                                method: method,
+                                body: body,
+                                headers: __assign({ 
+                                    // Must set this content type to bypass cors
+                                    // can override via headers if necessary (recommended for logevent)
+                                    'Content-Type': 'text/plain' }, args.headers),
+                                signal: controller.signal,
+                            })];
+                    case 2:
+                        response = _a.sent();
+                        clearTimeout(handle);
+                        return [4 /*yield*/, response.text()];
+                    case 3:
+                        text = _a.sent();
+                        if (!response.ok) {
+                            throw new NetworkError('Fetch Failure', text);
+                        }
+                        Diagnostics_1.Diagnostics.mark('_sendRequest:response-received', {
+                            status: response.status,
+                            contentLength: response.headers.get('content-length'),
+                        });
+                        return [2 /*return*/, text];
+                    case 4:
+                        error_1 = _a.sent();
+                        errorMessage = _getErrorMessage(controller, error_1);
+                        Diagnostics_1.Diagnostics.mark('_sendRequest:error', {
+                            error: errorMessage,
+                            status: response === null || response === void 0 ? void 0 : response.status,
+                            contentLength: response === null || response === void 0 ? void 0 : response.headers.get('content-length'),
+                        });
+                        if (!retries || retries <= 0) {
+                            Log_1.Log.error('A networking error occured.', errorMessage);
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, this._sendRequest(__assign(__assign({}, args), { retries: retries - 1 }))];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    NetworkCore.prototype._getPopulatedURL = function (args) {
+        var statsigMetadata = StatsigMetadata_1.StatsigMetadataProvider.get();
+        var fullUrl = new URL(args.url);
+        fullUrl.searchParams.append('k', args.sdkKey);
+        fullUrl.searchParams.append('st', statsigMetadata.sdkType);
+        fullUrl.searchParams.append('sv', statsigMetadata.sdkVersion);
+        fullUrl.searchParams.append('t', String(Date.now()));
+        fullUrl.searchParams.append('sid', SessionID_1.SessionID.get(args.sdkKey));
+        return fullUrl.toString();
+    };
+    return NetworkCore;
+}());
+exports.NetworkCore = NetworkCore;
+function _getErrorMessage(controller, error) {
+    if (controller.signal.aborted &&
+        typeof controller.signal.reason === 'string') {
+        return controller.signal.reason;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (error instanceof Error) {
+        return "".concat(error.name, ": ").concat(error.message);
+    }
+    return null;
+}

package/src/SessionID.d.ts

@@ -0,0 +1,3 @@
+export declare const SessionID: {
+    get: (sdkKey: string) => string;
+};

package/src/SessionID.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionID = void 0;
+var UUID_1 = require("./UUID");
+var SESSION_ID_MAP = {};
+exports.SessionID = {
+    get: function (sdkKey) {
+        if (SESSION_ID_MAP[sdkKey] == null) {
+            SESSION_ID_MAP[sdkKey] = (0, UUID_1.getUUID)();
+        }
+        return SESSION_ID_MAP[sdkKey];
+    },
+};

package/src/StableID.d.ts

@@ -0,0 +1,4 @@
+export declare const StableID: {
+    get: (sdkKey: string) => Promise<string>;
+    setOverride: (override: string, sdkKey: string) => void;
+};

package/src/StableID.js

@@ -0,0 +1,78 @@
+"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());
+    });
+};
+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 = {};
+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) {
+        PROMISE_MAP[sdkKey] = Promise.resolve(override);
+        _persistToStorage(override, sdkKey);
+    },
+};
+function _getStableIDStorageKey(sdkKey) {
+    return "STATSIG_STABLE_ID:".concat((0, Hashing_1.DJB2)(sdkKey));
+}
+function _persistToStorage(stableID, sdkKey) {
+    var storageKey = _getStableIDStorageKey(sdkKey);
+    (0, StorageProvider_1.setObjectInStorage)(storageKey, stableID).catch(function () {
+        Log_1.Log.warn('Failed to save StableID');
+    });
+}
+function _loadFromStorage(sdkKey) {
+    var storageKey = _getStableIDStorageKey(sdkKey);
+    return (0, StorageProvider_1.getObjectFromStorage)(storageKey);
+}

package/src/StatsigClientBase.d.ts

@@ -0,0 +1,37 @@
+import './$_StatsigGlobal';
+import { ErrorBoundary } from './ErrorBoundary';
+import { EventLogger } from './EventLogger';
+import { NetworkCore } from './NetworkCore';
+import { StatsigClientEvent, StatsigClientEventCallback, StatsigClientEventData, StatsigClientEventEmitterInterface, StatsigLoadingStatus } from './StatsigClientEventEmitter';
+import { DataSource, StatsigDataProvider } from './StatsigDataProvider';
+import { StatsigEventInternal } from './StatsigEvent';
+import { StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { StatsigUser } from './StatsigUser';
+type DataProviderResult = {
+    data: string | null;
+    source: DataSource;
+};
+export type EvaluationOptions = {
+    disableExposureLog?: boolean;
+};
+export declare const DEFAULT_EVAL_OPTIONS: EvaluationOptions;
+export type StatsigClientEmitEventFunc = (data: StatsigClientEventData) => void;
+export declare class StatsigClientBase implements StatsigClientEventEmitterInterface {
+    loadingStatus: StatsigLoadingStatus;
+    protected _errorBoundary: ErrorBoundary;
+    protected _logger: EventLogger;
+    protected _sdkKey: string;
+    protected _dataProviders: StatsigDataProvider[];
+    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(user?: StatsigUser): Promise<DataProviderResult>;
+    protected _saveToDataProviders(data: string | null, user?: StatsigUser): void;
+    protected _enqueueExposure(options: EvaluationOptions, exposure: StatsigEventInternal): void;
+}
+export {};