@statsig/client-core 0.0.1-beta.1

package/src/StatsigClientBase.js

@@ -0,0 +1,272 @@
+"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 };
+    }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsigClientBase = exports.DEFAULT_EVAL_OPTIONS = void 0;
+require("./$_StatsigGlobal");
+var ErrorBoundary_1 = require("./ErrorBoundary");
+var EventLogger_1 = require("./EventLogger");
+var Log_1 = require("./Log");
+var StableID_1 = require("./StableID");
+exports.DEFAULT_EVAL_OPTIONS = {
+    disableExposureLog: false,
+};
+var StatsigClientBase = /** @class */ (function () {
+    function StatsigClientBase(sdkKey, network, options, dataProviders) {
+        var _a, _b;
+        this.loadingStatus = 'Uninitialized';
+        this._listeners = {};
+        this._logger = new EventLogger_1.EventLogger(sdkKey, this.emit.bind(this), network, options);
+        this._sdkKey = sdkKey;
+        this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey);
+        if (options === null || options === void 0 ? void 0 : options.overrideStableID) {
+            StableID_1.StableID.setOverride(options.overrideStableID, sdkKey);
+        }
+        __STATSIG__ = __STATSIG__ !== null && __STATSIG__ !== void 0 ? __STATSIG__ : {};
+        var instances = (_a = __STATSIG__.instances) !== null && _a !== void 0 ? _a : new Set();
+        instances.add(this);
+        __STATSIG__.instances = instances;
+        Log_1.Log.level = (_b = options === null || options === void 0 ? void 0 : options.logLevel) !== null && _b !== void 0 ? _b : Log_1.LogLevel.Error;
+        this._dataProviders = dataProviders;
+    }
+    StatsigClientBase.prototype.on = function (event, listener) {
+        if (!this._listeners[event]) {
+            this._listeners[event] = [];
+        }
+        this._listeners[event].push(listener);
+    };
+    StatsigClientBase.prototype.off = function (event, listener) {
+        if (this._listeners[event]) {
+            var index = this._listeners[event].indexOf(listener);
+            if (index !== -1) {
+                this._listeners[event].splice(index, 1);
+            }
+        }
+    };
+    StatsigClientBase.prototype.emit = function (data) {
+        var _a;
+        if (this._listeners[data.event]) {
+            this._listeners[data.event].forEach(function (listener) { return listener(data); });
+        }
+        (_a = this._listeners['*']) === null || _a === void 0 ? void 0 : _a.forEach(function (listener) { return listener(data); });
+    };
+    StatsigClientBase.prototype._setStatus = function (newStatus) {
+        this.loadingStatus = newStatus;
+        this.emit({ event: 'status_change', loadingStatus: newStatus });
+    };
+    StatsigClientBase.prototype._getDataFromProviders = function (user) {
+        var _a;
+        for (var _i = 0, _b = this._dataProviders; _i < _b.length; _i++) {
+            var provider = _b[_i];
+            var data = (_a = provider.getData) === null || _a === void 0 ? void 0 : _a.call(provider, this._sdkKey, user);
+            if (data) {
+                return { data: data, source: provider.source };
+            }
+        }
+        return { data: null, source: 'NoValues' };
+    };
+    StatsigClientBase.prototype._getDataFromProvidersAsync = function (user) {
+        var _a, e_1, _b, _c;
+        var _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var _e, _f, _g, provider, data, e_1_1;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        _h.trys.push([0, 6, 7, 12]);
+                        _e = true, _f = __asyncValues(this._dataProviders);
+                        _h.label = 1;
+                    case 1: return [4 /*yield*/, _f.next()];
+                    case 2:
+                        if (!(_g = _h.sent(), _a = _g.done, !_a)) return [3 /*break*/, 5];
+                        _c = _g.value;
+                        _e = false;
+                        provider = _c;
+                        return [4 /*yield*/, ((_d = provider.getDataAsync) === null || _d === void 0 ? void 0 : _d.call(provider, this._sdkKey, user))];
+                    case 3:
+                        data = _h.sent();
+                        if (data) {
+                            return [2 /*return*/, { data: data, source: provider.source }];
+                        }
+                        _h.label = 4;
+                    case 4:
+                        _e = true;
+                        return [3 /*break*/, 1];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_1_1 = _h.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _h.trys.push([7, , 10, 11]);
+                        if (!(!_e && !_a && (_b = _f.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _b.call(_f)];
+                    case 8:
+                        _h.sent();
+                        _h.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_1) throw e_1.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/, { data: null, source: 'NoValues' }];
+                }
+            });
+        });
+    };
+    StatsigClientBase.prototype._getDataPostInitFromProviders = function (user) {
+        var _a, e_2, _b, _c;
+        var _d;
+        return __awaiter(this, void 0, void 0, function () {
+            var _e, _f, _g, provider, data, e_2_1;
+            return __generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        _h.trys.push([0, 6, 7, 12]);
+                        _e = true, _f = __asyncValues(this._dataProviders);
+                        _h.label = 1;
+                    case 1: return [4 /*yield*/, _f.next()];
+                    case 2:
+                        if (!(_g = _h.sent(), _a = _g.done, !_a)) return [3 /*break*/, 5];
+                        _c = _g.value;
+                        _e = false;
+                        provider = _c;
+                        return [4 /*yield*/, ((_d = provider.getDataPostInit) === null || _d === void 0 ? void 0 : _d.call(provider, this._sdkKey, user))];
+                    case 3:
+                        data = _h.sent();
+                        if (data) {
+                            return [2 /*return*/, { data: data, source: provider.source }];
+                        }
+                        _h.label = 4;
+                    case 4:
+                        _e = true;
+                        return [3 /*break*/, 1];
+                    case 5: return [3 /*break*/, 12];
+                    case 6:
+                        e_2_1 = _h.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 12];
+                    case 7:
+                        _h.trys.push([7, , 10, 11]);
+                        if (!(!_e && !_a && (_b = _f.return))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, _b.call(_f)];
+                    case 8:
+                        _h.sent();
+                        _h.label = 9;
+                    case 9: return [3 /*break*/, 11];
+                    case 10:
+                        if (e_2) throw e_2.error;
+                        return [7 /*endfinally*/];
+                    case 11: return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/, { data: null, source: 'NoValues' }];
+                }
+            });
+        });
+    };
+    StatsigClientBase.prototype._saveToDataProviders = function (data, user) {
+        var _this = this;
+        (function () { return __awaiter(_this, void 0, void 0, function () {
+            var localResult, _a, _b, _c, provider, e_3_1;
+            var _d, e_3, _e, _f;
+            var _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0: return [4 /*yield*/, this._getDataPostInitFromProviders(user)];
+                    case 1:
+                        localResult = _j.sent();
+                        data = (_g = localResult.data) !== null && _g !== void 0 ? _g : data;
+                        if (!data) {
+                            return [2 /*return*/];
+                        }
+                        _j.label = 2;
+                    case 2:
+                        _j.trys.push([2, 8, 9, 14]);
+                        _a = true, _b = __asyncValues(this._dataProviders);
+                        _j.label = 3;
+                    case 3: return [4 /*yield*/, _b.next()];
+                    case 4:
+                        if (!(_c = _j.sent(), _d = _c.done, !_d)) return [3 /*break*/, 7];
+                        _f = _c.value;
+                        _a = false;
+                        provider = _f;
+                        return [4 /*yield*/, ((_h = provider.setDataPostInit) === null || _h === void 0 ? void 0 : _h.call(provider, this._sdkKey, data, user))];
+                    case 5:
+                        _j.sent();
+                        _j.label = 6;
+                    case 6:
+                        _a = true;
+                        return [3 /*break*/, 3];
+                    case 7: return [3 /*break*/, 14];
+                    case 8:
+                        e_3_1 = _j.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 14];
+                    case 9:
+                        _j.trys.push([9, , 12, 13]);
+                        if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 11];
+                        return [4 /*yield*/, _e.call(_b)];
+                    case 10:
+                        _j.sent();
+                        _j.label = 11;
+                    case 11: return [3 /*break*/, 13];
+                    case 12:
+                        if (e_3) throw e_3.error;
+                        return [7 /*endfinally*/];
+                    case 13: return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        }); })().catch(function (error) {
+            _this.emit({ event: 'error', error: error });
+        });
+    };
+    StatsigClientBase.prototype._enqueueExposure = function (options, exposure) {
+        if (options.disableExposureLog === true) {
+            return;
+        }
+        this._logger.enqueue(exposure);
+    };
+    return StatsigClientBase;
+}());
+exports.StatsigClientBase = StatsigClientBase;

package/src/StatsigClientEventEmitter.d.ts

@@ -0,0 +1,33 @@
+import { DynamicConfig, Experiment, FeatureGate, Layer } from './StatsigTypes';
+export type StatsigLoadingStatus = 'Uninitialized' | 'Loading' | 'Ready' | 'Error';
+export type StatsigClientEvent = 'status_change' | 'error' | 'logs_flushed' | 'gate_evaluation' | 'dynamic_config_evaluation' | 'experiment_evaluation' | 'layer_evaluation';
+export type StatsigClientEventData = {
+    event: StatsigClientEvent;
+} | {
+    event: 'status_change';
+    loadingStatus: StatsigLoadingStatus;
+} | {
+    event: 'error';
+    error: unknown;
+} | {
+    event: 'logs_flushed';
+    events: Record<string, unknown>[];
+} | {
+    event: 'gate_evaluation';
+    gate: FeatureGate;
+} | {
+    event: 'dynamic_config_evaluation';
+    dynamicConfig: DynamicConfig;
+} | {
+    event: 'experiment_evaluation';
+    experiment: Experiment;
+} | {
+    event: 'layer_evaluation';
+    layer: Layer;
+};
+export type StatsigClientEventCallback = (data: StatsigClientEventData) => void;
+export interface StatsigClientEventEmitterInterface {
+    readonly loadingStatus: StatsigLoadingStatus;
+    on(event: StatsigClientEvent, listener: StatsigClientEventCallback): void;
+    off(event: StatsigClientEvent, listener: StatsigClientEventCallback): void;
+}

package/src/StatsigClientEventEmitter.js

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

package/src/StatsigDataProvider.d.ts

@@ -0,0 +1,9 @@
+import { StatsigUser } from './StatsigUser';
+export type DataSource = 'Uninitialized' | 'Loading' | 'NoValues' | 'Cache' | 'Network' | 'Bootstrap' | 'Prefetch';
+export type StatsigDataProvider = {
+    readonly getData?: (sdkKey: string, user?: StatsigUser) => string | null;
+    readonly getDataAsync?: (sdkKey: string, user?: StatsigUser) => Promise<string | null>;
+    readonly getDataPostInit?: (sdkKey: string, user?: StatsigUser) => Promise<string | null>;
+    readonly setDataPostInit?: (sdkKey: string, data: string, user?: StatsigUser) => Promise<void>;
+    readonly source: DataSource;
+};

package/src/StatsigDataProvider.js

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

package/src/StatsigEvent.d.ts

@@ -0,0 +1,31 @@
+import { DataSource } from './StatsigDataProvider';
+import { DynamicConfig, FeatureGate } from './StatsigTypes';
+import { StatsigUser } from './StatsigUser';
+export type SecondaryExposure = {
+    gate: string;
+    gateValue: string;
+    ruleID: string;
+};
+export type StatsigEvent = {
+    eventName: string;
+    value?: string | number | null;
+    metadata?: {
+        [key: string]: string;
+    } | null;
+};
+export type StatsigEventInternal = StatsigEvent & {
+    user: StatsigUser | null;
+    time: number;
+    secondaryExposures?: SecondaryExposure[];
+};
+export declare function isExposureEvent({ eventName }: StatsigEventInternal): boolean;
+export declare function createGateExposure(user: StatsigUser, gate: FeatureGate, secondaryExposures: SecondaryExposure[] | undefined): StatsigEventInternal;
+export declare function createConfigExposure(user: StatsigUser, config: DynamicConfig, secondaryExposures: SecondaryExposure[] | undefined): StatsigEventInternal;
+export declare function createLayerParameterExposure(user: StatsigUser, layerName: string, parameterName: string, spec: {
+    rule_id: string;
+    explicit_parameters: string[];
+    undelegated_secondary_exposures?: SecondaryExposure[];
+    secondary_exposures: SecondaryExposure[];
+    allocated_experiment_name: string;
+    source: DataSource;
+}): StatsigEventInternal;

package/src/StatsigEvent.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLayerParameterExposure = exports.createConfigExposure = exports.createGateExposure = exports.isExposureEvent = void 0;
+var CONFIG_EXPOSURE_NAME = 'statsig::config_exposure';
+var GATE_EXPOSURE_NAME = 'statsig::gate_exposure';
+var LAYER_EXPOSURE_NAME = 'statsig::layer_exposure';
+function createExposure(eventName, user, metadata, secondaryExposures) {
+    return {
+        eventName: eventName,
+        user: user,
+        value: null,
+        metadata: metadata,
+        secondaryExposures: secondaryExposures,
+        time: Date.now(),
+    };
+}
+function isExposureEvent(_a) {
+    var eventName = _a.eventName;
+    return eventName === GATE_EXPOSURE_NAME || eventName === CONFIG_EXPOSURE_NAME;
+}
+exports.isExposureEvent = isExposureEvent;
+function createGateExposure(user, gate, secondaryExposures) {
+    return createExposure(GATE_EXPOSURE_NAME, user, {
+        gate: gate.name,
+        gateValue: String(gate.value),
+        ruleID: gate.ruleID,
+        reason: gate.source,
+    }, secondaryExposures !== null && secondaryExposures !== void 0 ? secondaryExposures : []);
+}
+exports.createGateExposure = createGateExposure;
+function createConfigExposure(user, config, secondaryExposures) {
+    return createExposure(CONFIG_EXPOSURE_NAME, user, {
+        config: config.name,
+        ruleID: config.ruleID,
+        reason: config.source,
+    }, secondaryExposures !== null && secondaryExposures !== void 0 ? secondaryExposures : []);
+}
+exports.createConfigExposure = createConfigExposure;
+function createLayerParameterExposure(user, layerName, parameterName, spec) {
+    var _a;
+    var isExplicit = spec.explicit_parameters.includes(parameterName);
+    var allocatedExperiment = '';
+    var secondaryExposures = (_a = spec.undelegated_secondary_exposures) !== null && _a !== void 0 ? _a : [];
+    if (isExplicit) {
+        allocatedExperiment = spec.allocated_experiment_name;
+        secondaryExposures = spec.secondary_exposures;
+    }
+    return createExposure(LAYER_EXPOSURE_NAME, user, {
+        config: layerName,
+        parameterName: parameterName,
+        ruleID: spec.rule_id,
+        allocatedExperiment: allocatedExperiment,
+        isExplicitParameter: String(isExplicit),
+        reason: spec.source,
+    }, secondaryExposures);
+}
+exports.createLayerParameterExposure = createLayerParameterExposure;

package/src/StatsigMetadata.d.ts

@@ -0,0 +1,18 @@
+export type StatsigMetadata = {
+    readonly [key: string]: string | undefined;
+    readonly appVersion?: string;
+    readonly deviceModel?: string;
+    readonly deviceModelName?: string;
+    readonly locale?: string;
+    readonly sdkType: string;
+    readonly sdkVersion: string;
+    readonly stableID?: string;
+    readonly systemName?: string;
+    readonly systemVersion?: string;
+};
+export declare const StatsigMetadataProvider: {
+    get: () => StatsigMetadata;
+    add: (additions: {
+        [key: string]: string | undefined;
+    }) => void;
+};

package/src/StatsigMetadata.js

@@ -0,0 +1,25 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsigMetadataProvider = void 0;
+var SDK_VERSION = '0.0.1-beta.1';
+var metadata = {
+    sdkVersion: SDK_VERSION,
+    sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients
+};
+exports.StatsigMetadataProvider = {
+    get: function () { return metadata; },
+    add: function (additions) {
+        metadata = __assign(__assign({}, metadata), additions);
+    },
+};

package/src/StatsigOptionsCommon.d.ts

@@ -0,0 +1,48 @@
+import { LogLevel } from './Log';
+import { StatsigDataProvider } from './StatsigDataProvider';
+/** Common options for configuring the Statsig SDK. */
+export type StatsigOptionsCommon = {
+    /**
+     * The API to use for all SDK network requests. You should not need to override this
+     * unless you have another API that implements the Statsig API endpoints.
+     */
+    api?: string;
+    /**
+     * An object you can use to set environment variables that apply to all of your users
+     * in the same session.
+     */
+    environment?: StatsigEnvironment;
+    /**
+     * Overrides the auto-generated StableID that is set for the device.
+     */
+    overrideStableID?: string;
+    /**
+     * How much information is allowed to be printed to the console.
+     * Default: LogLevel.Error
+     */
+    logLevel?: LogLevel;
+    /**
+     * StatsigDataProvider implementors used to customize the initialization flow.
+     * Default: LocalStorageCache then Network
+     */
+    dataProviders?: StatsigDataProvider[];
+    /**
+     * The maximum amount of time (in milliseconds) that any network request can take
+     * before timing out. Default: 10,000 (10 seconds)
+     */
+    networkTimeoutMs?: number;
+    /**
+     * The maximum number of events to batch before flushing logs to Statsig.
+     * Default: 50
+     */
+    loggingBufferMaxSize?: number;
+    /**
+     * How often (in milliseconds) to flush logs to Statsig.
+     * Default: 10,000 (10 seconds)
+     */
+    loggingIntervalMs?: number;
+};
+export type StatsigEnvironment = {
+    tier?: string;
+    [key: string]: string | undefined;
+};

package/src/StatsigOptionsCommon.js

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

package/src/StatsigTypes.d.ts

@@ -0,0 +1,22 @@
+export type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type EvaluatedSpec = {
+    readonly name: string;
+    readonly ruleID: string;
+    readonly source: string;
+};
+export type FeatureGate = EvaluatedSpec & {
+    readonly value: boolean;
+};
+export type DynamicConfig = EvaluatedSpec & {
+    readonly value: Record<string, unknown>;
+};
+export type Experiment = DynamicConfig;
+export type Layer = EvaluatedSpec & {
+    readonly getValue: (parameterName: string) => unknown;
+};
+export declare function makeFeatureGate(name: string, source: string, ruleID?: string, value?: boolean): FeatureGate;
+export declare function makeDynamicConfig(name: string, source: string, ruleID?: string, value?: Record<string, unknown>): DynamicConfig;
+export declare function makeLayer(name: string, source: string, ruleID?: string, getValue?: (param: string) => unknown): Layer;
+export {};

package/src/StatsigTypes.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLayer = exports.makeDynamicConfig = exports.makeFeatureGate = void 0;
+var DEFAULT_RULE = 'default';
+function makeFeatureGate(name, source, ruleID, value) {
+    return {
+        name: name,
+        source: source,
+        ruleID: ruleID !== null && ruleID !== void 0 ? ruleID : DEFAULT_RULE,
+        value: value === true,
+    };
+}
+exports.makeFeatureGate = makeFeatureGate;
+function makeDynamicConfig(name, source, ruleID, value) {
+    return {
+        name: name,
+        source: source,
+        ruleID: ruleID !== null && ruleID !== void 0 ? ruleID : DEFAULT_RULE,
+        value: value !== null && value !== void 0 ? value : {},
+    };
+}
+exports.makeDynamicConfig = makeDynamicConfig;
+function makeLayer(name, source, ruleID, getValue) {
+    return {
+        name: name,
+        source: source,
+        getValue: getValue !== null && getValue !== void 0 ? getValue : (function () { return undefined; }),
+        ruleID: ruleID !== null && ruleID !== void 0 ? ruleID : DEFAULT_RULE,
+    };
+}
+exports.makeLayer = makeLayer;

package/src/StatsigUser.d.ts

@@ -0,0 +1,24 @@
+import type { StatsigEnvironment } from './StatsigOptionsCommon';
+type StatsigUserPrimitives = string | number | boolean | Array<string> | undefined;
+export type StatsigUser = ({
+    userID: string;
+} | {
+    customIDs: Record<string, string>;
+}) & {
+    userID?: string;
+    customIDs?: Record<string, string>;
+    email?: string;
+    ip?: string;
+    userAgent?: string;
+    country?: string;
+    locale?: string;
+    appVersion?: string;
+    custom?: Record<string, StatsigUserPrimitives>;
+    privateAttributes?: Record<string, StatsigUserPrimitives> | null;
+};
+export type StatsigUserInternal = StatsigUser & {
+    statsigEnvironment?: StatsigEnvironment;
+};
+export declare function normalizeUser(original: StatsigUser, environment?: StatsigEnvironment): StatsigUser;
+export declare function getUserStorageKey(sdkKey: string, user?: StatsigUser): string;
+export {};

package/src/StatsigUser.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserStorageKey = exports.normalizeUser = void 0;
+var Hashing_1 = require("./Hashing");
+function normalizeUser(original, environment) {
+    try {
+        var copy = JSON.parse(JSON.stringify(original));
+        if (environment != null) {
+            copy.statsigEnvironment = environment;
+        }
+        return copy;
+    }
+    catch (error) {
+        throw new Error('User object must be convertable to JSON string.');
+    }
+}
+exports.normalizeUser = normalizeUser;
+function getUserStorageKey(sdkKey, user) {
+    var _a, _b;
+    var parts = [
+        "uid:".concat((_a = user === null || user === void 0 ? void 0 : user.userID) !== null && _a !== void 0 ? _a : ''),
+        "cids:".concat(Object.entries((_b = user === null || user === void 0 ? void 0 : user.customIDs) !== null && _b !== void 0 ? _b : {})
+            .sort(function (_a, _b) {
+            var leftKey = _a[0];
+            var rightKey = _b[0];
+            return leftKey.localeCompare(rightKey);
+        })
+            .map(function (_a) {
+            var key = _a[0], value = _a[1];
+            return "".concat(key, "-").concat(value);
+        })
+            .join(',')),
+        "k:".concat(sdkKey),
+    ];
+    return (0, Hashing_1.DJB2)(parts.join('|'));
+}
+exports.getUserStorageKey = getUserStorageKey;

package/src/StorageProvider.d.ts

@@ -0,0 +1,11 @@
+type StorageProvider = {
+    getItem: (key: string) => Promise<string | null>;
+    setItem: (key: string, value: string) => Promise<void>;
+    removeItem: (key: string) => Promise<void>;
+};
+export declare const Storage: StorageProvider & {
+    setProvider: (n: StorageProvider) => void;
+};
+export declare function getObjectFromStorage<T>(key: string): Promise<T | null>;
+export declare function setObjectInStorage(key: string, obj: unknown): Promise<void>;
+export {};