@mangostudio/cli-darwin-arm64 0.1.0 → 0.1.1-canary.00a342c

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigClientBase.js

@@ -0,0 +1,207 @@
+"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.StatsigClientBase = void 0;
+require("./$_StatsigGlobal");
+const __StatsigGlobal_1 = require("./$_StatsigGlobal");
+const ErrorBoundary_1 = require("./ErrorBoundary");
+const EventLogger_1 = require("./EventLogger");
+const Log_1 = require("./Log");
+const MemoKey_1 = require("./MemoKey");
+const SafeJs_1 = require("./SafeJs");
+const SessionID_1 = require("./SessionID");
+const StableID_1 = require("./StableID");
+const StatsigOptionsCommon_1 = require("./StatsigOptionsCommon");
+const StorageProvider_1 = require("./StorageProvider");
+const MAX_MEMO_CACHE_SIZE = 3000;
+class StatsigClientBase {
+    constructor(sdkKey, adapter, network, options) {
+        var _a, _b, _c, _d;
+        this.loadingStatus = 'Uninitialized';
+        this._initializePromise = null;
+        this._listeners = {};
+        const emitter = this.$emt.bind(this);
+        (options === null || options === void 0 ? void 0 : options.logLevel) != null && (Log_1.Log.level = options.logLevel);
+        (options === null || options === void 0 ? void 0 : options.disableStorage) && StorageProvider_1.Storage._setDisabled(true);
+        (options === null || options === void 0 ? void 0 : options.initialSessionID) &&
+            SessionID_1.StatsigSession.overrideInitialSessionID(options.initialSessionID, sdkKey);
+        (options === null || options === void 0 ? void 0 : options.storageProvider) && StorageProvider_1.Storage._setProvider(options.storageProvider);
+        (options === null || options === void 0 ? void 0 : options.enableCookies) &&
+            StableID_1.StableID._setCookiesEnabled(sdkKey, options.enableCookies);
+        (options === null || options === void 0 ? void 0 : options.disableStableID) && StableID_1.StableID._setDisabled(sdkKey, true);
+        this._sdkKey = sdkKey;
+        this._options = options !== null && options !== void 0 ? options : {};
+        this._memoCache = {};
+        this.overrideAdapter = (_a = options === null || options === void 0 ? void 0 : options.overrideAdapter) !== null && _a !== void 0 ? _a : null;
+        this._logger = new EventLogger_1.EventLogger(sdkKey, emitter, network, options);
+        this._errorBoundary = new ErrorBoundary_1.ErrorBoundary(sdkKey, options, emitter);
+        this._errorBoundary.wrap(this);
+        this._errorBoundary.wrap(adapter);
+        this._errorBoundary.wrap(this._logger);
+        network.setErrorBoundary(this._errorBoundary);
+        this.dataAdapter = adapter;
+        this.dataAdapter.attach(sdkKey, options, network);
+        this.storageProvider = StorageProvider_1.Storage;
+        (_d = (_c = (_b = this.overrideAdapter) === null || _b === void 0 ? void 0 : _b.loadFromStorage) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.catch((e) => this._errorBoundary.logError('OA::loadFromStorage', e));
+        this._primeReadyRipcord();
+        _assignGlobalInstance(sdkKey, this);
+    }
+    /**
+     * 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) {
+        if (options.loggingEnabled) {
+            this._options.loggingEnabled = options.loggingEnabled;
+            this._logger.setLoggingEnabled(options.loggingEnabled);
+        }
+        else if (options.disableLogging != null) {
+            this._options.disableLogging = options.disableLogging;
+            this._logger.setLoggingEnabled(options.disableLogging ? 'disabled' : 'browser-only');
+        }
+        if (options.disableStorage != null) {
+            this._options.disableStorage = options.disableStorage;
+            StorageProvider_1.Storage._setDisabled(options.disableStorage);
+        }
+        if (options.enableCookies != null) {
+            this._options.enableCookies = options.enableCookies;
+            StableID_1.StableID._setCookiesEnabled(this._sdkKey, options.enableCookies);
+        }
+        if (options.logEventCompressionMode) {
+            this._logger.setLogEventCompressionMode(options.logEventCompressionMode);
+        }
+        else if (options.disableCompression) {
+            this._logger.setLogEventCompressionMode(StatsigOptionsCommon_1.LogEventCompressionMode.Disabled);
+        }
+    }
+    /**
+     * Flushes any currently queued events.
+     */
+    flush() {
+        return this._logger.flush();
+    }
+    /**
+     * 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() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$emt({ name: 'pre_shutdown' });
+            this._setStatus('Uninitialized', null);
+            this._initializePromise = null;
+            yield this._logger.stop();
+        });
+    }
+    /**
+     * 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(event, listener) {
+        if (!this._listeners[event]) {
+            this._listeners[event] = [];
+        }
+        this._listeners[event].push(listener);
+    }
+    /**
+     * 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(event, listener) {
+        if (this._listeners[event]) {
+            const index = this._listeners[event].indexOf(listener);
+            if (index !== -1) {
+                this._listeners[event].splice(index, 1);
+            }
+        }
+    }
+    $on(event, listener) {
+        listener.__isInternal = true;
+        this.on(event, listener);
+    }
+    $emt(event) {
+        var _a;
+        const barrier = (listener) => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                if (listener.__isInternal === true) {
+                    this._errorBoundary.logError(`__emit:${event.name}`, error);
+                    return;
+                }
+                Log_1.Log.error(`An error occurred in a StatsigClientEvent listener. This is not an issue with Statsig.`, event);
+            }
+        };
+        if (this._listeners[event.name]) {
+            this._listeners[event.name].forEach((l) => barrier(l));
+        }
+        (_a = this._listeners['*']) === null || _a === void 0 ? void 0 : _a.forEach(barrier);
+    }
+    _setStatus(newStatus, values) {
+        this.loadingStatus = newStatus;
+        this._memoCache = {};
+        this.$emt({ name: 'values_updated', status: newStatus, values });
+    }
+    _enqueueExposure(name, exposure, options) {
+        if ((options === null || options === void 0 ? void 0 : options.disableExposureLog) === true) {
+            this._logger.incrementNonExposureCount(name);
+            return;
+        }
+        this._logger.enqueue(exposure);
+    }
+    _memoize(prefix, fn) {
+        return (name, options) => {
+            if (this._options.disableEvaluationMemoization) {
+                return fn(name, options);
+            }
+            const memoKey = (0, MemoKey_1.createMemoKey)(prefix, name, options);
+            if (!memoKey) {
+                return fn(name, options);
+            }
+            if (!(memoKey in this._memoCache)) {
+                if (Object.keys(this._memoCache).length >= MAX_MEMO_CACHE_SIZE) {
+                    this._memoCache = {};
+                }
+                this._memoCache[memoKey] = fn(name, options);
+            }
+            return this._memoCache[memoKey];
+        };
+    }
+}
+exports.StatsigClientBase = StatsigClientBase;
+function _assignGlobalInstance(sdkKey, client) {
+    var _a;
+    if ((0, SafeJs_1._isServerEnv)()) {
+        return;
+    }
+    const statsigGlobal = (0, __StatsigGlobal_1._getStatsigGlobal)();
+    const instances = (_a = statsigGlobal.instances) !== null && _a !== void 0 ? _a : {};
+    const inst = client;
+    if (instances[sdkKey] != null) {
+        Log_1.Log.warn('Creating multiple Statsig clients with the same SDK key can lead to unexpected behavior. Multi-instance support requires different SDK keys.');
+    }
+    instances[sdkKey] = inst;
+    if (!statsigGlobal.firstInstance) {
+        statsigGlobal.firstInstance = inst;
+    }
+    statsigGlobal.instances = instances;
+    __STATSIG__ = statsigGlobal;
+}

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigClientEventEmitter.d.ts

@@ -0,0 +1,100 @@
+import { DataAdapterResult } from './StatsigDataAdapter';
+import { StatsigEvent } from './StatsigEvent';
+import { DynamicConfig, Experiment, FeatureGate, Layer } from './StatsigTypes';
+import { Flatten } from './TypingUtils';
+export type StatsigLoadingStatus = 'Uninitialized' | 'Loading' | 'Ready';
+export declare const ErrorTag: {
+    readonly NetworkError: "NetworkError";
+};
+export type ErrorTag = (typeof ErrorTag)[keyof typeof ErrorTag];
+type ErrorEventData = {
+    error: unknown;
+    tag: ErrorTag | string;
+} | {
+    error: unknown;
+    tag: 'NetworkError';
+    requestArgs: Record<string, unknown>;
+};
+type EventNameToEventDataMap = {
+    values_updated: {
+        status: StatsigLoadingStatus;
+        values: DataAdapterResult | null;
+    };
+    session_expired: object;
+    error: ErrorEventData;
+    pre_logs_flushed: {
+        events: Record<string, unknown>[];
+    };
+    logs_flushed: {
+        events: Record<string, unknown>[];
+    };
+    pre_shutdown: object;
+    initialization_failure: object;
+    gate_evaluation: {
+        gate: FeatureGate;
+    };
+    dynamic_config_evaluation: {
+        dynamicConfig: DynamicConfig;
+    };
+    experiment_evaluation: {
+        experiment: Experiment;
+    };
+    layer_evaluation: {
+        layer: Layer;
+    };
+    log_event_called: {
+        event: StatsigEvent;
+    };
+};
+/**
+ * Type representing various events emitted by a Statsig client.
+ *
+ * `values_updated` - When the Statsig clients internal values change as the result of an initialize/update operation.
+ *
+ * `session_expired` - When the current session has expired.
+ *
+ * `error` - When an unexpected error occurs within the Statsig client.
+ *
+ * `pre_logs_flushed` - Fired just before queued StatsigEvents are flushed to Statsig servers.
+ *
+ * `logs_flushed` - When queued StatsigEvents are flushed to Statsig servers.
+ *
+ * `pre_shutdown` - Fired just before the SDK is shutdown
+ *
+ * `initialization_failure` - Fired when the client fails to initialize.
+ *
+ * `gate_evaluation` - Fired when any gate is checked from the Statsig client.
+ *
+ * `dynamic_config_evaluation` - Fired when any dyanamic config is checked from the Statsig client.
+ *
+ * `experiment_evaluation` - Fired when any experiment is checked from the Statsig client.
+ *
+ * `layer_evaluation` - Fired when any layer is checked from the Statsig client.
+ *
+ * `log_event_called` - Fired when log event is called.
+ */
+export type AnyStatsigClientEvent = Flatten<{
+    [K in keyof EventNameToEventDataMap]: {
+        name: K;
+    } & EventNameToEventDataMap[K];
+}[keyof EventNameToEventDataMap]>;
+export type StatsigClientEvent<T> = Extract<AnyStatsigClientEvent, {
+    name: T;
+}>;
+export type AnyStatsigClientEventListener = StatsigClientEventCallback<StatsigClientEventName>;
+export type StatsigClientEventName = AnyStatsigClientEvent['name'] | '*';
+export type StatsigClientEventCallback<T extends StatsigClientEventName> = (event: T extends '*' ? AnyStatsigClientEvent : StatsigClientEvent<T>) => void;
+export interface StatsigClientEventEmitterInterface {
+    readonly loadingStatus: StatsigLoadingStatus;
+    on<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    off<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    /**
+     * (Statsig Use Only) - Same as .on() but logs errors to sdk_exception
+     */
+    $on<T extends StatsigClientEventName>(event: T, listener: StatsigClientEventCallback<T>): void;
+    /**
+     * (Statsig Use Only) - Emit StatsigClientEvents
+     */
+    $emt(event: AnyStatsigClientEvent): void;
+}
+export {};

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigClientEventEmitter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorTag = void 0;
+exports.ErrorTag = {
+    NetworkError: 'NetworkError',
+};

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigDataAdapter.d.ts

@@ -0,0 +1,131 @@
+import { NetworkPriority } from './NetworkConfig';
+import { NetworkCore } from './NetworkCore';
+import type { AnyStatsigOptions, NetworkConfigCommon } from './StatsigOptionsCommon';
+import { StatsigUser } from './StatsigUser';
+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 type DataAdapterSyncOptions = {
+    /**
+     * The flag to disable background cache refresh.
+     * If set to true, a network request to update the cache for future sessions will not fired.
+     * if "explicitly" set to false, a network request to update the cache for future sessions will be fired, even in bootstrap cases.
+     *
+     * default: implicit false
+     */
+    readonly disableBackgroundCacheRefresh?: boolean;
+};
+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 `StatsigOptions.dataAdapter`.
+ *
+ * defaults:
+ *
+ * - {@link StatsigClient} uses {@link EvaluationsDataAdapter}
+ *
+ * - {@link StatsigOnDeviceEvalClient} uses {@link SpecsDataAdapter}
+ */
+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: AnyStatsigOptions | null, network: NetworkCore) => 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 specs data. Called during initializeSync and/or updateUserSync.
+     * It is also called during async update operations before StatsigDataAdapter.getDataAsync is called.
+     * @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 prefetchData: (options?: DataAdapterAsyncOptions) => Promise<void>;
+    /**
+     * Manually set specs data (Bootstrap).
+     */
+    readonly setData: (data: string) => void;
+};
+export {};

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigDataAdapter.js

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigEvent.d.ts

@@ -0,0 +1,28 @@
+import { SecondaryExposure } from './EvaluationTypes';
+import { DynamicConfig, FeatureGate, Layer } from './StatsigTypes';
+import { StatsigUserInternal } from './StatsigUser';
+export type StatsigEvent = {
+    eventName: string;
+    value?: string | number | null;
+    metadata?: {
+        [key: string]: string | undefined;
+    } | null;
+};
+export type BootstrapMetadata = {
+    generatorSDKInfo?: Record<string, string>;
+    lcut?: number;
+    user?: Record<string, unknown>;
+};
+export type StatsigEventInternal = Omit<StatsigEvent, 'metadata'> & {
+    user: StatsigUserInternal | null;
+    time: number;
+    metadata?: {
+        [key: string]: unknown;
+    } | null;
+    secondaryExposures?: SecondaryExposure[];
+};
+export declare const _isExposureEvent: ({ eventName, }: StatsigEventInternal) => boolean;
+export declare const _createGateExposure: (user: StatsigUserInternal, gate: FeatureGate, exposureMapping?: Record<string, SecondaryExposure>) => StatsigEventInternal;
+export declare function _mapExposures(exposures: SecondaryExposure[] | string[], exposureMapping?: Record<string, SecondaryExposure>): SecondaryExposure[];
+export declare const _createConfigExposure: (user: StatsigUserInternal, config: DynamicConfig, exposureMapping?: Record<string, SecondaryExposure>) => StatsigEventInternal;
+export declare const _createLayerParameterExposure: (user: StatsigUserInternal, layer: Layer, parameterName: string, exposureMapping?: Record<string, SecondaryExposure>) => StatsigEventInternal;

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigEvent.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._createLayerParameterExposure = exports._createConfigExposure = exports._mapExposures = 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) => {
+    if (details.bootstrapMetadata) {
+        metadata['bootstrapMetadata'] = details.bootstrapMetadata;
+    }
+    return {
+        eventName,
+        user,
+        value: null,
+        metadata: _addEvaluationDetailsToMetadata(details, metadata),
+        secondaryExposures,
+        time: Date.now(),
+    };
+};
+const _isExposureEvent = ({ eventName, }) => {
+    return (eventName === GATE_EXPOSURE_NAME ||
+        eventName === CONFIG_EXPOSURE_NAME ||
+        eventName === LAYER_EXPOSURE_NAME);
+};
+exports._isExposureEvent = _isExposureEvent;
+const _createGateExposure = (user, gate, exposureMapping) => {
+    var _a, _b, _c;
+    const metadata = {
+        gate: gate.name,
+        gateValue: String(gate.value),
+        ruleID: gate.ruleID,
+    };
+    if (((_a = gate.__evaluation) === null || _a === void 0 ? void 0 : _a.version) != null) {
+        metadata['configVersion'] = gate.__evaluation.version;
+    }
+    return _createExposure(GATE_EXPOSURE_NAME, user, gate.details, metadata, _mapExposures((_c = (_b = gate.__evaluation) === null || _b === void 0 ? void 0 : _b.secondary_exposures) !== null && _c !== void 0 ? _c : [], exposureMapping));
+};
+exports._createGateExposure = _createGateExposure;
+function _mapExposures(exposures, exposureMapping) {
+    return exposures
+        .map((exposure) => {
+        if (typeof exposure === 'string') {
+            return (exposureMapping !== null && exposureMapping !== void 0 ? exposureMapping : {})[exposure];
+        }
+        return exposure;
+    })
+        .filter((exposure) => exposure != null);
+}
+exports._mapExposures = _mapExposures;
+const _createConfigExposure = (user, config, exposureMapping) => {
+    var _a, _b, _c, _d;
+    const metadata = {
+        config: config.name,
+        ruleID: config.ruleID,
+    };
+    if (((_a = config.__evaluation) === null || _a === void 0 ? void 0 : _a.version) != null) {
+        metadata['configVersion'] = config.__evaluation.version;
+    }
+    if (((_b = config.__evaluation) === null || _b === void 0 ? void 0 : _b.passed) != null) {
+        metadata['rulePassed'] = String(config.__evaluation.passed);
+    }
+    return _createExposure(CONFIG_EXPOSURE_NAME, user, config.details, metadata, _mapExposures((_d = (_c = config.__evaluation) === null || _c === void 0 ? void 0 : _c.secondary_exposures) !== null && _d !== void 0 ? _d : [], exposureMapping));
+};
+exports._createConfigExposure = _createConfigExposure;
+const _createLayerParameterExposure = (user, layer, parameterName, exposureMapping) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    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 = (_c = evaluation.allocated_experiment_name) !== null && _c !== void 0 ? _c : '';
+        secondaryExposures = (_d = evaluation.secondary_exposures) !== null && _d !== void 0 ? _d : [];
+    }
+    const parameterRuleIDs = (_e = layer.__evaluation) === null || _e === void 0 ? void 0 : _e.parameter_rule_ids;
+    const metadata = {
+        config: layer.name,
+        parameterName,
+        ruleID: (_f = parameterRuleIDs === null || parameterRuleIDs === void 0 ? void 0 : parameterRuleIDs[parameterName]) !== null && _f !== void 0 ? _f : layer.ruleID,
+        allocatedExperiment,
+        isExplicitParameter: String(isExplicit),
+    };
+    if (((_g = layer.__evaluation) === null || _g === void 0 ? void 0 : _g.version) != null) {
+        metadata['configVersion'] = layer.__evaluation.version;
+    }
+    return _createExposure(LAYER_EXPOSURE_NAME, user, layer.details, metadata, _mapExposures(secondaryExposures, exposureMapping));
+};
+exports._createLayerParameterExposure = _createLayerParameterExposure;
+const _addEvaluationDetailsToMetadata = (details, metadata) => {
+    metadata['reason'] = details.reason;
+    if (details.lcut) {
+        metadata['lcut'] = String(details.lcut);
+    }
+    if (details.receivedAt) {
+        metadata['receivedAt'] = String(details.receivedAt);
+    }
+    return metadata;
+};

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigMetadata.d.ts

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

package/cursor-sidecar/node_modules/@statsig/client-core/src/StatsigMetadata.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsigMetadataProvider = exports.SDK_VERSION = void 0;
+exports.SDK_VERSION = '3.31.0';
+let metadata = {
+    sdkVersion: exports.SDK_VERSION,
+    sdkType: 'js-mono', // js-mono is overwritten by Precomp and OnDevice clients
+};
+exports.StatsigMetadataProvider = {
+    get: () => metadata,
+    add: (additions) => {
+        metadata = Object.assign(Object.assign({}, metadata), additions);
+    },
+};