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

package/src/StatsigDataAdapter.d.ts

@@ -1,40 +1,126 @@
-import { StatsigOptionsCommon } from './StatsigOptionsCommon';
+import { NetworkPriority } from './NetworkConfig';
+import type { AnyStatsigOptions, NetworkConfigCommon } from './StatsigOptionsCommon';
 import { StatsigUser } from './StatsigUser';
-export type DataSource = 'Uninitialized' | 'Loading' | 'NoValues' | 'Cache' | 'Network' | 'NetworkNotModified' | 'Bootstrap';
-export type StatsigDataAdapterResult = {
+export type DataSource = 'Uninitialized' | 'Loading' | 'NoValues' | 'Cache' | 'Network' | 'NetworkNotModified' | 'Bootstrap' | 'Prefetch';
+export type DataAdapterResult = {
     readonly source: DataSource;
     readonly data: string;
+    readonly receivedAt: number;
+    readonly stableID: string | null;
+    readonly fullUserHash: string | null;
 };
+export type DataAdapterAsyncOptions = {
+    /**
+     * The maximum amount of time (in milliseconds) this operation is permitted to run.
+     * If the timeout is hit, null is returned but any in-flight requests are kept alive with results going to cache for future updates.
+     *
+     * Note: If no timeout is given, the {@link NetworkConfigCommon.networkTimeoutMs|StatsigOptions.networkConfig.networkTimeoutMs} is used.
+     */
+    readonly timeoutMs?: NetworkConfigCommon['networkTimeoutMs'];
+    /**
+     * The priority that should be applied to the Http request that is fired.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/fetch#priority
+     *
+     * default: 'auto'
+     */
+    readonly priority?: NetworkPriority;
+};
+export declare const DataAdapterCachePrefix = "statsig.cached";
 /**
  * Describes a type that is used during intialize/update operations of a Statsig client.
  *
  * See below to find the default adapters, but know that it is possible to create your
- * own StatsigDataAdapter and provide it via {@link StatsigOptions.dataAdapter}.
+ * own StatsigDataAdapter and provide it via `StatsigOptions.dataAdapter`.
  *
- * Defaults:
+ * defaults:
  *
- * - {@link PrecomputedEvaluationsClient} uses {@link EvaluationsDataAdapter}
+ * - {@link StatsigClient} uses {@link EvaluationsDataAdapter}
  *
- * - {@link OnDeviceEvaluationsClient} uses {@link SpecsDataAdapter}
+ * - {@link StatsigOnDeviceEvalClient} uses {@link SpecsDataAdapter}
  */
-export type StatsigDataAdapter = {
+type DataAdapterCommon = {
     /**
      * Called when the StatsigDataAdapter is attached to the Statsig client instance during construction.
      * @param {string} sdkKey The SDK key being used by the Statsig client.
      * @param {StatsigOptionsCommon | null} options The StatsigOptions being used by the Statsig client.
      */
-    readonly attach: (sdkKey: string, options: StatsigOptionsCommon | null) => void;
+    readonly attach: (sdkKey: string, options: AnyStatsigOptions | null) => 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
+     */
+    readonly __primeInMemoryCache: (cache: Record<string, DataAdapterResult>) => void;
+};
+export type EvaluationsDataAdapter = DataAdapterCommon & {
+    /**
+     * Synchronously get evaluation data for the given user. Called during initializeSync and/or updateUserSync.
+     *
+     * It is also called during async update operations before StatsigDataAdapter.getDataAsync is called.
+     * @param {StatsigUser} user The StatsigUser to get data for.
+     * @returns {DataAdapterResult | null} The data that was found for the given StatsigUser.
+     */
+    readonly getDataSync: (user: StatsigUser) => DataAdapterResult | null;
+    /**
+     * Asynchronously get evaluation data for the given user. Called during initializeAsync and/or updateUserAsync.
+     *
+     * @param {DataAdapterResult | null} current The data that was found synchronously (Cache). Will be used as fallback if getDataAsync fails
+     * @param {StatsigUser} user The StatsigUser to get data for.
+     * @returns {DataAdapterResult | null} The data that was found for the given StatsigUser.
+     */
+    readonly getDataAsync: (current: DataAdapterResult | null, user: StatsigUser, options?: DataAdapterAsyncOptions) => Promise<DataAdapterResult | null>;
+    /**
+     * Manually trigger a fetch for new evaluations data for the given user.
+     *
+     * @param {StatsigUser} user The StatsigUser to get data for.
+     */
+    readonly prefetchData: (user: StatsigUser, options?: DataAdapterAsyncOptions) => Promise<void>;
+    /**
+     * Manually set the evaluations data from a JSON string.
+     *
+     * Statsig Server SDKs supported:
+     *  - node-js-server-sdk\@5.20.0
+     *  - java-server-sdk\@1.18.0
+     *  - python-sdk\@0.32.0
+     *  - ruby-sdk\@1.34.0
+     *  - dotnet-sdk\@1.25.0
+     *  - php-sdk\@3.2.0
+     *
+     * Note: You can use {@link EvaluationsDataAdapter.setDataLegacy} if your server is running an older Statsig Server SDK.
+     */
+    readonly setData: (data: string) => void;
+    /**
+     * Manually set evaluations data for the given user.
+     *
+     * @param {StatsigUser} user The StatsigUser this data is for.
+     *
+     * @deprecated This method is provided only to support older versions of Statsig server SDKs.
+     *  Newer SDKs include the StatsigUser as part of the data string, and can be used with the {@link EvaluationsDataAdapter.setData} method instead.
+     */
+    readonly setDataLegacy: (data: string, user: StatsigUser) => void;
+};
+export type SpecsDataAdapter = DataAdapterCommon & {
     /**
-     * Synchronously get data for the given user (if any). Called during initializeSync and/or updateUserSync.
+     * Synchronously get specs data. Called during initializeSync and/or updateUserSync.
      * It is also called during async update operations before StatsigDataAdapter.getDataAsync is called.
-     * @param {StatsigUser | undefined} user The StatsigUser to get data for.
-     * @returns {StatsigDataAdapterResult | null} The data that was found for the given StatsigUser.
+     * @returns {DataAdapterResult | null} The data that was found for the given StatsigUser.
+     */
+    readonly getDataSync: () => DataAdapterResult | null;
+    /**
+     * Asynchronously get specs data. Called during initializeAsync and/or updateUserAsync.
+     *
+     * @param {DataAdapterResult | null} current The data that was found synchronously (Cache). Will be used as fallback if getDataAsync fails
+     * @returns {DataAdapterResult | null} The data that was found for the given StatsigUser.
+     */
+    readonly getDataAsync: (current: DataAdapterResult | null, options?: DataAdapterAsyncOptions) => Promise<DataAdapterResult | null>;
+    /**
+     * Manually trigger a fetch for new specs data.
      */
-    readonly getDataSync: (user?: StatsigUser) => StatsigDataAdapterResult | null;
+    readonly prefetchData: (options?: DataAdapterAsyncOptions) => Promise<void>;
     /**
-     * Asynchronously get data for the given user (if any). Called during initializeAsync and/or updateUserAsync.
-     * @param {StatsigUser | undefined} user The StatsigUser to get data for.
-     * @returns {StatsigDataAdapterResult | null} The data that was found for the given StatsigUser.
+     * Manually set specs data (Bootstrap).
      */
-    readonly getDataAsync: (current: StatsigDataAdapterResult | null, user?: StatsigUser) => Promise<StatsigDataAdapterResult | null>;
+    readonly setData: (data: string) => void;
 };
+export {};

package/src/StatsigDataAdapter.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataAdapterCachePrefix = void 0;
+exports.DataAdapterCachePrefix = 'statsig.cached';

package/src/StatsigEvent.d.ts

@@ -1,10 +1,6 @@
-import { DynamicConfig, EvaluationDetails, FeatureGate } from './StatsigTypes';
+import { SecondaryExposure } from './EvaluationTypes';
+import { DynamicConfig, FeatureGate, Layer } from './StatsigTypes';
 import { StatsigUser } from './StatsigUser';
-export type SecondaryExposure = {
-    gate: string;
-    gateValue: string;
-    ruleID: string;
-};
 export type StatsigEvent = {
     eventName: string;
     value?: string | number | null;
@@ -12,19 +8,15 @@ export type StatsigEvent = {
         [key: string]: string;
     } | null;
 };
-export type StatsigEventInternal = StatsigEvent & {
+export type StatsigEventInternal = Omit<StatsigEvent, 'metadata'> & {
     user: StatsigUser | null;
     time: number;
+    metadata?: {
+        [key: string]: unknown;
+    } | null;
     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;
-    details: EvaluationDetails;
-}): StatsigEventInternal;
+export declare const _isExposureEvent: ({ eventName, }: StatsigEventInternal) => boolean;
+export declare const _createGateExposure: (user: StatsigUser, gate: FeatureGate) => StatsigEventInternal;
+export declare const _createConfigExposure: (user: StatsigUser, config: DynamicConfig) => StatsigEventInternal;
+export declare const _createLayerParameterExposure: (user: StatsigUser, layer: Layer, parameterName: string) => StatsigEventInternal;

package/src/StatsigEvent.js

@@ -1,58 +1,60 @@
 "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, details, metadata, secondaryExposures) {
+exports._createLayerParameterExposure = exports._createConfigExposure = exports._createGateExposure = exports._isExposureEvent = void 0;
+const CONFIG_EXPOSURE_NAME = 'statsig::config_exposure';
+const GATE_EXPOSURE_NAME = 'statsig::gate_exposure';
+const LAYER_EXPOSURE_NAME = 'statsig::layer_exposure';
+const _createExposure = (eventName, user, details, metadata, secondaryExposures) => {
     return {
-        eventName: eventName,
-        user: user,
+        eventName,
+        user,
         value: null,
         metadata: _addEvaluationDetailsToMetadata(details, metadata),
-        secondaryExposures: secondaryExposures,
+        secondaryExposures,
         time: Date.now(),
     };
-}
-function isExposureEvent(_a) {
-    var eventName = _a.eventName;
+};
+const _isExposureEvent = ({ 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.details, {
+};
+exports._isExposureEvent = _isExposureEvent;
+const _createGateExposure = (user, gate) => {
+    var _a, _b;
+    return _createExposure(GATE_EXPOSURE_NAME, user, gate.details, {
         gate: gate.name,
         gateValue: String(gate.value),
         ruleID: gate.ruleID,
-    }, secondaryExposures !== null && secondaryExposures !== void 0 ? secondaryExposures : []);
-}
-exports.createGateExposure = createGateExposure;
-function createConfigExposure(user, config, secondaryExposures) {
-    return createExposure(CONFIG_EXPOSURE_NAME, user, config.details, {
+    }, (_b = (_a = gate.__evaluation) === null || _a === void 0 ? void 0 : _a.secondary_exposures) !== null && _b !== void 0 ? _b : []);
+};
+exports._createGateExposure = _createGateExposure;
+const _createConfigExposure = (user, config) => {
+    var _a, _b;
+    return _createExposure(CONFIG_EXPOSURE_NAME, user, config.details, {
         config: config.name,
         ruleID: config.ruleID,
-    }, 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 : [];
+    }, (_b = (_a = config.__evaluation) === null || _a === void 0 ? void 0 : _a.secondary_exposures) !== null && _b !== void 0 ? _b : []);
+};
+exports._createConfigExposure = _createConfigExposure;
+const _createLayerParameterExposure = (user, layer, parameterName) => {
+    var _a, _b, _c;
+    const evaluation = layer.__evaluation;
+    const isExplicit = ((_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.explicit_parameters) === null || _a === void 0 ? void 0 : _a.includes(parameterName)) === true;
+    let allocatedExperiment = '';
+    let secondaryExposures = (_b = evaluation === null || evaluation === void 0 ? void 0 : evaluation.undelegated_secondary_exposures) !== null && _b !== void 0 ? _b : [];
     if (isExplicit) {
-        allocatedExperiment = spec.allocated_experiment_name;
-        secondaryExposures = spec.secondary_exposures;
+        allocatedExperiment = (_c = evaluation.allocated_experiment_name) !== null && _c !== void 0 ? _c : '';
+        secondaryExposures = evaluation.secondary_exposures;
     }
-    return createExposure(LAYER_EXPOSURE_NAME, user, spec.details, {
-        config: layerName,
-        parameterName: parameterName,
-        ruleID: spec.rule_id,
-        allocatedExperiment: allocatedExperiment,
+    return _createExposure(LAYER_EXPOSURE_NAME, user, layer.details, {
+        config: layer.name,
+        parameterName,
+        ruleID: layer.ruleID,
+        allocatedExperiment,
         isExplicitParameter: String(isExplicit),
     }, secondaryExposures);
-}
-exports.createLayerParameterExposure = createLayerParameterExposure;
-function _addEvaluationDetailsToMetadata(details, metadata) {
+};
+exports._createLayerParameterExposure = _createLayerParameterExposure;
+const _addEvaluationDetailsToMetadata = (details, metadata) => {
     metadata['reason'] = details.reason;
     if (details.lcut) {
         metadata['lcut'] = String(details.lcut);
@@ -61,4 +63,4 @@ function _addEvaluationDetailsToMetadata(details, metadata) {
         metadata['receivedAt'] = String(details.receivedAt);
     }
     return metadata;
-}
+};

package/src/StatsigMetadata.d.ts

@@ -1,10 +1,10 @@
+export declare const SDK_VERSION = "1.0.1";
 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;

package/src/StatsigMetadata.js

@@ -1,25 +1,14 @@
 "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.9';
-var metadata = {
-    sdkVersion: SDK_VERSION,
+exports.StatsigMetadataProvider = exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = '1.0.1';
+let metadata = {
+    sdkVersion: exports.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);
+    get: () => metadata,
+    add: (additions) => {
+        metadata = Object.assign(Object.assign({}, metadata), additions);
     },
 };

package/src/StatsigOptionsCommon.d.ts

@@ -1,47 +1,111 @@
 import { LogLevel } from './Log';
-import { StatsigDataAdapter } from './StatsigDataAdapter';
-/** Common options for configuring the Statsig SDK. */
-export type StatsigOptionsCommon = {
+import { NetworkArgs } from './NetworkConfig';
+import { OverrideAdapter } from './OverrideAdapter';
+/** Options that can be set at init and updated during runtime. */
+export type StatsigRuntimeMutableOptions = {
+    /**
+     * Prevents sending any events over the network.
+     */
+    disableLogging?: boolean;
+    /**
+     * Prevents writing anything to storage.
+     *
+     * Note: caching will not work if storage is disabled
+     */
+    disableStorage?: boolean;
+};
+export type NetworkConfigCommon = {
     /**
      * 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.
+     * unless you have a custom API that implements the Statsig endpoints.
      */
     api?: string;
     /**
-     * An object you can use to set environment variables that apply to all of your users
-     * in the same session.
+     * The URL used to flush queued events via a POST request. Takes precedence over {@link StatsigOptionsCommon.api}.
+     *
+     * default: `https://featuregates.org/v1/initialize`
      */
-    environment?: StatsigEnvironment;
+    logEventUrl?: string;
     /**
-     * Overrides the auto-generated StableID that is set for the device.
+     * The maximum amount of time (in milliseconds) that any network request can take
+     * before timing out.
+     *
+     * default: `10,000 ms` (10 seconds)
      */
-    overrideStableID?: string;
+    networkTimeoutMs?: number;
     /**
-     * How much information is allowed to be printed to the console.
-     * Default: LogLevel.Warn
+     * Intended for testing purposes. Prevents any network requests being made.
      */
-    logLevel?: LogLevel;
+    preventAllNetworkTraffic?: boolean;
     /**
-     * StatsigDataAdapter implementor used to customize the initialization/update flow.
-     * Default: EvaluationsDataAdapter (Precomputed) or SpecsDataAdapter (OnDevice)
+     * Overrides the default networking layer used by the Statsig client.
+     * By default, the client use `fetch`, but overriding this
+     * you could use `axios` or raw `XMLHttpRequest`
+     *
+     * default: `Fetch API`
+     *
+     * @param {string} url Where the request is going.
+     * @param {NetworkArgs} args Configuration for the network request.
+     * @returns {Response}
      */
-    dataAdapter?: StatsigDataAdapter;
+    networkOverrideFunc?: (url: string, args: NetworkArgs) => Promise<Response>;
+};
+/** Options for configuring a Statsig client. */
+export type StatsigOptionsCommon<NetworkConfig extends NetworkConfigCommon> = StatsigRuntimeMutableOptions & {
     /**
-     * The maximum amount of time (in milliseconds) that any network request can take
-     * before timing out. Default: 10,000 (10 seconds)
+     * Allows for fine grained control over which api or urls are hit for specific Statsig network requests.
+     *
+     * For defaults see {@link StatsigClientUrlOverrideOptions}
      */
-    networkTimeoutMs?: number;
+    networkConfig?: NetworkConfig;
+    /**
+     * An object you can use to set environment variables that apply to all of your users
+     * in the same session.
+     */
+    environment?: StatsigEnvironment;
+    /**
+     * How much information is allowed to be printed to the console.
+     *
+     * default: {@link LogLevel.Warn}
+     */
+    logLevel?: LogLevel;
     /**
      * The maximum number of events to batch before flushing logs to Statsig.
-     * Default: 50
+     *
+     * default: `50`
      */
     loggingBufferMaxSize?: number;
     /**
      * How often (in milliseconds) to flush logs to Statsig.
-     * Default: 10,000 (10 seconds)
+     *
+     * default: `10,000 ms`  (10 seconds)
      */
     loggingIntervalMs?: number;
+    /**
+     * An implementor of {@link OverrideAdapter}, used to alter evaluations before its
+     * returned to the caller of a check api (checkGate/getExperiment etc).
+     */
+    overrideAdapter?: OverrideAdapter;
+    /**
+     * (Web only) Should the 'current page' url be included with logged events.
+     *
+     * default: true
+     */
+    includeCurrentPageUrlWithEvents?: boolean;
+    /**
+     * Whether or not Statsig should use raw JSON for network requests where possible.
+     *
+     * default: `false`
+     */
+    disableStatsigEncoding?: boolean;
+    /**
+     * Whether or not Statsig should compress JSON bodies for network requests where possible.
+     *
+     * default: `false`
+     */
+    disableCompression?: boolean;
 };
+export type AnyStatsigOptions = StatsigOptionsCommon<NetworkConfigCommon>;
 export type StatsigEnvironment = {
     tier?: string;
     [key: string]: string | undefined;

package/src/StatsigTypeFactories.d.ts

@@ -0,0 +1,6 @@
+import { DynamicConfigEvaluation, EvaluationDetails, GateEvaluation, LayerEvaluation } from './EvaluationTypes';
+import { AnyConfigBasedStatsigType, DynamicConfig, FeatureGate, Layer } from './StatsigTypes';
+export declare function _makeFeatureGate(name: string, details: EvaluationDetails, evaluation: GateEvaluation | null): FeatureGate;
+export declare function _makeDynamicConfig(name: string, details: EvaluationDetails, evaluation: DynamicConfigEvaluation | null): DynamicConfig;
+export declare function _makeLayer(name: string, details: EvaluationDetails, evaluation: LayerEvaluation | null, exposeFunc?: (param: string) => void): Layer;
+export declare function _mergeOverride<T extends AnyConfigBasedStatsigType>(original: T, overridden: T | null | undefined, value: Record<string, unknown>, exposeFunc?: (param: string) => void): T;

package/src/StatsigTypeFactories.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._mergeOverride = exports._makeLayer = exports._makeDynamicConfig = exports._makeFeatureGate = void 0;
+const DEFAULT_RULE = 'default';
+function _makeEvaluation(name, details, evaluation, value) {
+    var _a;
+    return {
+        name,
+        details,
+        ruleID: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.rule_id) !== null && _a !== void 0 ? _a : DEFAULT_RULE,
+        __evaluation: evaluation,
+        value,
+    };
+}
+function _makeFeatureGate(name, details, evaluation) {
+    return _makeEvaluation(name, details, evaluation, (evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) === true);
+}
+exports._makeFeatureGate = _makeFeatureGate;
+function _makeDynamicConfig(name, details, evaluation) {
+    var _a;
+    return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) !== null && _a !== void 0 ? _a : {})), { groupName: null, get: _makeTypedGet(evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) });
+}
+exports._makeDynamicConfig = _makeDynamicConfig;
+function _makeLayer(name, details, evaluation, exposeFunc) {
+    var _a, _b;
+    return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, undefined)), { get: _makeTypedGet(evaluation === null || evaluation === void 0 ? void 0 : evaluation.value, exposeFunc), groupName: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.group_name) !== null && _a !== void 0 ? _a : null, __value: (_b = evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) !== null && _b !== void 0 ? _b : {} });
+}
+exports._makeLayer = _makeLayer;
+function _mergeOverride(original, overridden, value, exposeFunc) {
+    return Object.assign(Object.assign(Object.assign({}, original), overridden), { get: _makeTypedGet(value, exposeFunc) });
+}
+exports._mergeOverride = _mergeOverride;
+function _isTypeMatch(a, b) {
+    const typeOf = (x) => (Array.isArray(x) ? 'array' : typeof x);
+    return typeOf(a) === typeOf(b);
+}
+function _makeTypedGet(value, exposeFunc) {
+    return (param, fallback) => {
+        var _a;
+        const found = (_a = value === null || value === void 0 ? void 0 : value[param]) !== null && _a !== void 0 ? _a : null;
+        if (found == null) {
+            return (fallback !== null && fallback !== void 0 ? fallback : null);
+        }
+        if (fallback != null && !_isTypeMatch(found, fallback)) {
+            return (fallback !== null && fallback !== void 0 ? fallback : null);
+        }
+        exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(param);
+        return found;
+    };
+}

package/src/StatsigTypes.d.ts

@@ -1,27 +1,33 @@
-export type Flatten<T> = {
-    [K in keyof T]: T[K];
-} & {};
-export type EvaluationDetails = {
-    reason: string;
-    lcut?: number;
-    receivedAt?: number;
-};
-type EvaluatedSpec = {
+import { EvaluationDetails, ExperimentEvaluation, GateEvaluation, LayerEvaluation } from './EvaluationTypes';
+import { Flatten } from './UtitlityTypes';
+export type TypedGet = <T = unknown>(key: string, fallback?: T) => TypedReturn<T>;
+export type TypedReturn<T = unknown> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : T extends Array<unknown> ? Array<unknown> : T extends object ? object : unknown;
+export type SpecType = 'gate' | 'dynamic_config' | 'experiment' | 'layer';
+export type FeatureGate = Flatten<{
     readonly name: string;
     readonly ruleID: string;
     readonly details: EvaluationDetails;
-};
-export type FeatureGate = EvaluatedSpec & {
     readonly value: boolean;
-};
-export type DynamicConfig = EvaluatedSpec & {
+    readonly __evaluation: GateEvaluation | null;
+}>;
+export type Experiment = Flatten<{
+    readonly name: string;
+    readonly ruleID: string;
+    readonly details: EvaluationDetails;
     readonly value: Record<string, unknown>;
-};
-export type Experiment = DynamicConfig;
-export type Layer = EvaluatedSpec & {
-    readonly getValue: (parameterName: string) => unknown;
-};
-export declare function makeFeatureGate(name: string, details: EvaluationDetails, ruleID?: string, value?: boolean): FeatureGate;
-export declare function makeDynamicConfig(name: string, details: EvaluationDetails, ruleID?: string, value?: Record<string, unknown>): DynamicConfig;
-export declare function makeLayer(name: string, details: EvaluationDetails, ruleID?: string, getValue?: (param: string) => unknown): Layer;
-export {};
+    readonly groupName: string | null;
+    readonly __evaluation: ExperimentEvaluation | null;
+    readonly get: TypedGet;
+}>;
+export type DynamicConfig = Flatten<Experiment>;
+export type Layer = Flatten<{
+    readonly name: string;
+    readonly ruleID: string;
+    readonly details: EvaluationDetails;
+    readonly groupName: string | null;
+    readonly __value: Record<string, unknown>;
+    readonly __evaluation: LayerEvaluation | null;
+    readonly get: TypedGet;
+}>;
+export type AnyConfigBasedStatsigType = DynamicConfig | Experiment | Layer;
+export type AnyStatsigType = FeatureGate | AnyConfigBasedStatsigType;

package/src/StatsigTypes.js

@@ -1,31 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeLayer = exports.makeDynamicConfig = exports.makeFeatureGate = void 0;
-var DEFAULT_RULE = 'default';
-function makeFeatureGate(name, details, ruleID, value) {
-    return {
-        name: name,
-        details: details,
-        ruleID: ruleID !== null && ruleID !== void 0 ? ruleID : DEFAULT_RULE,
-        value: value === true,
-    };
-}
-exports.makeFeatureGate = makeFeatureGate;
-function makeDynamicConfig(name, details, ruleID, value) {
-    return {
-        name: name,
-        details: details,
-        ruleID: ruleID !== null && ruleID !== void 0 ? ruleID : DEFAULT_RULE,
-        value: value !== null && value !== void 0 ? value : {},
-    };
-}
-exports.makeDynamicConfig = makeDynamicConfig;
-function makeLayer(name, details, ruleID, getValue) {
-    return {
-        name: name,
-        details: details,
-        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

@@ -1,12 +1,11 @@
 import type { StatsigEnvironment } from './StatsigOptionsCommon';
 type StatsigUserPrimitives = string | number | boolean | Array<string> | undefined;
-export type StatsigUser = ({
-    userID: string;
-} | {
-    customIDs: Record<string, string>;
-}) & {
+export type StatsigUser = {
     userID?: string;
-    customIDs?: Record<string, string>;
+    customIDs?: {
+        [key: string]: string | undefined;
+        stableID?: string;
+    };
     email?: string;
     ip?: string;
     userAgent?: string;
@@ -19,6 +18,6 @@ export type StatsigUser = ({
 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 declare function _normalizeUser(original: StatsigUser, environment?: StatsigEnvironment): StatsigUser;
+export declare function _getFullUserHash(user: StatsigUser | undefined): string | null;
 export {};