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

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

@@ -0,0 +1,349 @@
+"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.EventLogger = void 0;
+const CacheKey_1 = require("./CacheKey");
+const Hashing_1 = require("./Hashing");
+const Log_1 = require("./Log");
+const NetworkConfig_1 = require("./NetworkConfig");
+const SafeJs_1 = require("./SafeJs");
+const StatsigEvent_1 = require("./StatsigEvent");
+const StatsigOptionsCommon_1 = require("./StatsigOptionsCommon");
+const StorageProvider_1 = require("./StorageProvider");
+const UrlConfiguration_1 = require("./UrlConfiguration");
+const VisibilityObserving_1 = require("./VisibilityObserving");
+const DEFAULT_QUEUE_SIZE = 100;
+const DEFAULT_FLUSH_INTERVAL_MS = 10000;
+const MAX_DEDUPER_KEYS = 1000;
+const DEDUPER_WINDOW_DURATION_MS = 600000;
+const MAX_FAILED_LOGS = 500;
+const QUICK_FLUSH_WINDOW_MS = 200;
+const EVENT_LOGGER_MAP = {};
+class EventLogger {
+    static _safeFlushAndForget(sdkKey) {
+        var _a;
+        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a.flush().catch(() => {
+            // noop
+        });
+    }
+    static _safeRetryFailedLogs(sdkKey) {
+        var _a;
+        (_a = EVENT_LOGGER_MAP[sdkKey]) === null || _a === void 0 ? void 0 : _a._retryFailedLogs();
+    }
+    constructor(_sdkKey, _emitter, _network, _options) {
+        var _a, _b;
+        this._sdkKey = _sdkKey;
+        this._emitter = _emitter;
+        this._network = _network;
+        this._options = _options;
+        this._queue = [];
+        this._lastExposureTimeMap = {};
+        this._nonExposedChecks = {};
+        this._hasRunQuickFlush = false;
+        this._creationTime = Date.now();
+        this._loggingEnabled =
+            (_a = _options === null || _options === void 0 ? void 0 : _options.loggingEnabled) !== null && _a !== void 0 ? _a : ((_options === null || _options === void 0 ? void 0 : _options.disableLogging) === true
+                ? StatsigOptionsCommon_1.LoggingEnabledOption.disabled
+                : StatsigOptionsCommon_1.LoggingEnabledOption.browserOnly);
+        if ((_options === null || _options === void 0 ? void 0 : _options.loggingEnabled) && _options.disableLogging !== undefined) {
+            Log_1.Log.warn('Detected both loggingEnabled and disableLogging options. loggingEnabled takes precedence - please remove disableLogging.');
+        }
+        this._maxQueueSize = (_b = _options === null || _options === void 0 ? void 0 : _options.loggingBufferMaxSize) !== null && _b !== void 0 ? _b : DEFAULT_QUEUE_SIZE;
+        const config = _options === null || _options === void 0 ? void 0 : _options.networkConfig;
+        this._logEventUrlConfig = new UrlConfiguration_1.UrlConfiguration(NetworkConfig_1.Endpoint._rgstr, config === null || config === void 0 ? void 0 : config.logEventUrl, config === null || config === void 0 ? void 0 : config.api, config === null || config === void 0 ? void 0 : config.logEventFallbackUrls);
+    }
+    setLogEventCompressionMode(mode) {
+        this._network.setLogEventCompressionMode(mode);
+    }
+    setLoggingEnabled(loggingEnabled) {
+        if (this._loggingEnabled === 'disabled' && loggingEnabled !== 'disabled') {
+            // load any pre consented events into memory
+            const storageKey = this._getStorageKey();
+            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            if (events) {
+                this._queue.push(...events);
+            }
+            StorageProvider_1.Storage.removeItem(storageKey);
+        }
+        this._loggingEnabled = loggingEnabled;
+    }
+    enqueue(event) {
+        if (!this._shouldLogEvent(event)) {
+            return;
+        }
+        this._normalizeAndAppendEvent(event);
+        this._quickFlushIfNeeded();
+        if (this._queue.length > this._maxQueueSize) {
+            EventLogger._safeFlushAndForget(this._sdkKey);
+        }
+    }
+    incrementNonExposureCount(name) {
+        var _a;
+        const current = (_a = this._nonExposedChecks[name]) !== null && _a !== void 0 ? _a : 0;
+        this._nonExposedChecks[name] = current + 1;
+    }
+    reset() {
+        // attempt to flush any remaining events
+        this.flush().catch(() => {
+            // noop
+        });
+        this._lastExposureTimeMap = {};
+    }
+    start() {
+        var _a;
+        const isServerEnv = (0, SafeJs_1._isServerEnv)();
+        if (isServerEnv && ((_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingEnabled) !== 'always') {
+            return;
+        }
+        EVENT_LOGGER_MAP[this._sdkKey] = this;
+        if (!isServerEnv) {
+            (0, VisibilityObserving_1._subscribeToVisiblityChanged)((visibility) => {
+                if (visibility === 'background') {
+                    EventLogger._safeFlushAndForget(this._sdkKey);
+                }
+                else if (visibility === 'foreground') {
+                    EventLogger._safeRetryFailedLogs(this._sdkKey);
+                }
+            });
+        }
+        this._retryFailedLogs();
+        this._startBackgroundFlushInterval();
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._flushIntervalId) {
+                clearInterval(this._flushIntervalId);
+                this._flushIntervalId = null;
+            }
+            delete EVENT_LOGGER_MAP[this._sdkKey];
+            yield this.flush();
+        });
+    }
+    flush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._appendAndResetNonExposedChecks();
+            if (this._queue.length === 0) {
+                return;
+            }
+            const events = this._queue;
+            this._queue = [];
+            yield this._sendEvents(events);
+        });
+    }
+    /**
+     * We 'Quick Flush' following the very first event enqueued
+     * within the quick flush window
+     */
+    _quickFlushIfNeeded() {
+        if (this._hasRunQuickFlush) {
+            return;
+        }
+        this._hasRunQuickFlush = true;
+        if (Date.now() - this._creationTime > QUICK_FLUSH_WINDOW_MS) {
+            return;
+        }
+        setTimeout(() => EventLogger._safeFlushAndForget(this._sdkKey), QUICK_FLUSH_WINDOW_MS);
+    }
+    _shouldLogEvent(event) {
+        var _a;
+        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingEnabled) !== 'always' && (0, SafeJs_1._isServerEnv)()) {
+            return false;
+        }
+        if (!(0, StatsigEvent_1._isExposureEvent)(event)) {
+            return true;
+        }
+        const user = event.user ? event.user : { statsigEnvironment: undefined };
+        const userKey = (0, CacheKey_1._getUserStorageKey)(this._sdkKey, user);
+        const metadata = event.metadata ? event.metadata : {};
+        const key = [
+            event.eventName,
+            userKey,
+            metadata['gate'],
+            metadata['config'],
+            metadata['ruleID'],
+            metadata['allocatedExperiment'],
+            metadata['parameterName'],
+            String(metadata['isExplicitParameter']),
+            metadata['reason'],
+        ].join('|');
+        const previous = this._lastExposureTimeMap[key];
+        const now = Date.now();
+        if (previous && now - previous < DEDUPER_WINDOW_DURATION_MS) {
+            return false;
+        }
+        if (Object.keys(this._lastExposureTimeMap).length > MAX_DEDUPER_KEYS) {
+            this._lastExposureTimeMap = {};
+        }
+        this._lastExposureTimeMap[key] = now;
+        return true;
+    }
+    _sendEvents(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this._loggingEnabled === 'disabled') {
+                this._saveFailedLogsToStorage(events);
+                return false;
+            }
+            try {
+                const isClosing = (0, VisibilityObserving_1._isUnloading)();
+                const shouldUseBeacon = isClosing &&
+                    this._network.isBeaconSupported() &&
+                    ((_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.networkConfig) === null || _b === void 0 ? void 0 : _b.networkOverrideFunc) == null;
+                this._emitter({
+                    name: 'pre_logs_flushed',
+                    events,
+                });
+                const response = shouldUseBeacon
+                    ? this._sendEventsViaBeacon(events)
+                    : yield this._sendEventsViaPost(events);
+                if (response.success) {
+                    this._emitter({
+                        name: 'logs_flushed',
+                        events,
+                    });
+                    return true;
+                }
+                else {
+                    Log_1.Log.warn('Failed to flush events.');
+                    this._saveFailedLogsToStorage(events);
+                    return false;
+                }
+            }
+            catch (_c) {
+                Log_1.Log.warn('Failed to flush events.');
+                return false;
+            }
+        });
+    }
+    _sendEventsViaPost(events) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = yield this._network.post(this._getRequestData(events));
+            const code = (_a = result === null || result === void 0 ? void 0 : result.code) !== null && _a !== void 0 ? _a : -1;
+            return { success: code >= 200 && code < 300 };
+        });
+    }
+    _sendEventsViaBeacon(events) {
+        return {
+            success: this._network.beacon(this._getRequestData(events)),
+        };
+    }
+    _getRequestData(events) {
+        return {
+            sdkKey: this._sdkKey,
+            data: {
+                events,
+            },
+            urlConfig: this._logEventUrlConfig,
+            retries: 3,
+            isCompressable: true,
+            params: {
+                [NetworkConfig_1.NetworkParam.EventCount]: String(events.length),
+            },
+            credentials: 'same-origin',
+        };
+    }
+    _saveFailedLogsToStorage(events) {
+        while (events.length > MAX_FAILED_LOGS) {
+            events.shift();
+        }
+        const storageKey = this._getStorageKey();
+        try {
+            const savedEvents = this._getFailedLogsFromStorage(storageKey);
+            (0, StorageProvider_1._setObjectInStorage)(storageKey, [...savedEvents, ...events]);
+        }
+        catch (_a) {
+            Log_1.Log.warn('Unable to save failed logs to storage');
+        }
+    }
+    _getFailedLogsFromStorage(storageKey) {
+        let savedEvents = [];
+        try {
+            const retrieved = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            if (Array.isArray(retrieved)) {
+                savedEvents = retrieved;
+            }
+            return savedEvents;
+        }
+        catch (_a) {
+            return [];
+        }
+    }
+    _retryFailedLogs() {
+        const storageKey = this._getStorageKey();
+        (() => __awaiter(this, void 0, void 0, function* () {
+            if (!StorageProvider_1.Storage.isReady()) {
+                yield StorageProvider_1.Storage.isReadyResolver();
+            }
+            const events = (0, StorageProvider_1._getObjectFromStorage)(storageKey);
+            if (!events) {
+                return;
+            }
+            StorageProvider_1.Storage.removeItem(storageKey);
+            yield this._sendEvents(events);
+        }))().catch(() => {
+            Log_1.Log.warn('Failed to flush stored logs');
+        });
+    }
+    _getStorageKey() {
+        return `statsig.failed_logs.${(0, Hashing_1._DJB2)(this._sdkKey)}`;
+    }
+    _normalizeAndAppendEvent(event) {
+        if (event.user) {
+            event.user = Object.assign({}, event.user);
+            delete event.user.privateAttributes;
+        }
+        const extras = {};
+        const currentPage = this._getCurrentPageUrl();
+        if (currentPage) {
+            extras.statsigMetadata = { currentPage };
+        }
+        const final = Object.assign(Object.assign({}, event), extras);
+        Log_1.Log.debug('Enqueued Event:', final);
+        this._queue.push(final);
+    }
+    _appendAndResetNonExposedChecks() {
+        if (Object.keys(this._nonExposedChecks).length === 0) {
+            return;
+        }
+        this._normalizeAndAppendEvent({
+            eventName: 'statsig::non_exposed_checks',
+            user: null,
+            time: Date.now(),
+            metadata: {
+                checks: Object.assign({}, this._nonExposedChecks),
+            },
+        });
+        this._nonExposedChecks = {};
+    }
+    _getCurrentPageUrl() {
+        var _a;
+        if (((_a = this._options) === null || _a === void 0 ? void 0 : _a.includeCurrentPageUrlWithEvents) === false) {
+            return;
+        }
+        return (0, SafeJs_1._getCurrentPageUrlSafe)();
+    }
+    _startBackgroundFlushInterval() {
+        var _a, _b;
+        const flushInterval = (_b = (_a = this._options) === null || _a === void 0 ? void 0 : _a.loggingIntervalMs) !== null && _b !== void 0 ? _b : DEFAULT_FLUSH_INTERVAL_MS;
+        const intervalId = setInterval(() => {
+            const logger = EVENT_LOGGER_MAP[this._sdkKey];
+            if (!logger || logger._flushIntervalId !== intervalId) {
+                clearInterval(intervalId);
+            }
+            else {
+                EventLogger._safeFlushAndForget(this._sdkKey);
+            }
+        }, flushInterval);
+        this._flushIntervalId = intervalId;
+    }
+}
+exports.EventLogger = EventLogger;

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

@@ -0,0 +1,7 @@
+export declare const EventRetryConstants: {
+    readonly MAX_RETRY_ATTEMPTS: 5;
+    readonly DEFAULT_BATCH_SIZE: 100;
+    readonly MAX_PENDING_BATCHES: 10;
+    readonly TICK_INTERVAL_MS: 1000;
+    readonly MAX_QUEUED_EVENTS: number;
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventRetryConstants = void 0;
+exports.EventRetryConstants = {
+    MAX_RETRY_ATTEMPTS: 5,
+    DEFAULT_BATCH_SIZE: 100,
+    MAX_PENDING_BATCHES: 10,
+    TICK_INTERVAL_MS: 1000,
+    get MAX_QUEUED_EVENTS() {
+        return this.DEFAULT_BATCH_SIZE * this.MAX_PENDING_BATCHES;
+    },
+};

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

@@ -0,0 +1,3 @@
+export declare const _DJB2: (value: string) => string;
+export declare const _DJB2Object: (value: Record<string, unknown> | null, maxLevels?: number) => string;
+export declare const _getSortedObject: (object: Record<string, unknown> | null, maxDepth: number | undefined) => Record<string, unknown> | null;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getSortedObject = exports._DJB2Object = exports._DJB2 = void 0;
+const TypingUtils_1 = require("./TypingUtils");
+const _DJB2 = (value) => {
+    let hash = 0;
+    for (let i = 0; i < value.length; i++) {
+        const character = value.charCodeAt(i);
+        hash = (hash << 5) - hash + character;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return String(hash >>> 0);
+};
+exports._DJB2 = _DJB2;
+const _DJB2Object = (value, maxLevels) => {
+    return (0, exports._DJB2)(JSON.stringify((0, exports._getSortedObject)(value, maxLevels)));
+};
+exports._DJB2Object = _DJB2Object;
+const _getSortedObject = (object, maxDepth) => {
+    if (object == null) {
+        return null;
+    }
+    const keys = Object.keys(object).sort();
+    const sortedObject = {};
+    keys.forEach((key) => {
+        const value = object[key];
+        if (maxDepth === 0 || (0, TypingUtils_1._typeOf)(value) !== 'object') {
+            sortedObject[key] = value;
+            return;
+        }
+        sortedObject[key] = (0, exports._getSortedObject)(value, maxDepth != null ? maxDepth - 1 : maxDepth);
+    });
+    return sortedObject;
+};
+exports._getSortedObject = _getSortedObject;

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

@@ -0,0 +1,66 @@
+import { DynamicConfigEvaluation, GateEvaluation, LayerEvaluation, SecondaryExposure } from './EvaluationTypes';
+import { DynamicConfigEvaluationV2, GateEvaluationV2, LayerEvaluationV2 } from './EvaluationTypesV2';
+import { ParamStoreConfig } from './ParamStoreTypes';
+import { StatsigUser } from './StatsigUser';
+type SessionReplayFields = {
+    can_record_session?: boolean;
+    recording_blocked?: boolean;
+    session_recording_rate?: number;
+    passes_session_recording_targeting?: boolean;
+    session_recording_event_triggers?: Record<string, SessionReplayTrigger>;
+    session_recording_exposure_triggers?: Record<string, SessionReplayTrigger>;
+    session_recording_privacy_settings?: SessionReplayPrivacySettings;
+};
+type SessionReplayTrigger = {
+    values?: string[];
+    passes_sampling?: boolean;
+};
+export type SessionReplayPrivacySettings = {
+    privacy_mode?: 'min' | 'input' | 'max';
+    unmasked_elements?: string[];
+    masked_elements?: string[];
+    blocked_elements?: string[];
+};
+type AutoCaptureFields = {
+    auto_capture_settings?: {
+        disabled_events: Record<string, boolean>;
+    };
+};
+type InitResponseCommon = SessionReplayFields & AutoCaptureFields & {
+    param_stores?: Record<string, ParamStoreConfig>;
+    time: number;
+    has_updates: true;
+    hash_used: 'none' | 'sha256' | 'djb2';
+    user: StatsigUser;
+    sdkInfo?: Record<string, string>;
+    sdkParams?: Record<string, unknown>;
+    generator?: string;
+    evaluated_keys?: Record<string, unknown>;
+    pa_hash?: string;
+    derived_fields?: Record<string, unknown>;
+    sdk_flags?: Record<string, boolean>;
+    full_checksum?: string;
+    exposures?: Record<string, SecondaryExposure>;
+};
+export type InitializeResponseV1WithUpdates = InitResponseCommon & {
+    feature_gates: Record<string, GateEvaluation>;
+    dynamic_configs: Record<string, DynamicConfigEvaluation>;
+    layer_configs: Record<string, LayerEvaluation>;
+    response_format?: 'init-v1' | null | undefined;
+};
+export type InitializeResponseV2 = InitResponseCommon & {
+    feature_gates: Record<string, GateEvaluationV2>;
+    dynamic_configs: Record<string, DynamicConfigEvaluationV2>;
+    layer_configs: Record<string, LayerEvaluationV2>;
+    values: Record<string, Record<string, unknown>>;
+    response_format: 'init-v2';
+};
+export type InitializeResponse = InitializeResponseV1WithUpdates | {
+    has_updates: false;
+};
+export type ClientInitializeResponseOptions = {
+    hash?: 'none' | 'sha256' | 'djb2';
+    clientSDKKey?: string;
+};
+export type AnyInitializeResponse = InitializeResponseV1WithUpdates | InitializeResponseV2;
+export {};

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

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

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

@@ -0,0 +1,15 @@
+export declare const LogLevel: {
+    readonly None: 0;
+    readonly Error: 1;
+    readonly Warn: 2;
+    readonly Info: 3;
+    readonly Debug: 4;
+};
+export type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
+export declare abstract class Log {
+    static level: LogLevel;
+    static info(...args: unknown[]): void;
+    static debug(...args: unknown[]): void;
+    static warn(...args: unknown[]): void;
+    static error(...args: unknown[]): void;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+/* eslint-disable no-console */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.LogLevel = void 0;
+// intentionally spaced for formatting
+const DEBUG = ' DEBUG ';
+const _INFO = '  INFO ';
+const _WARN = '  WARN ';
+const ERROR = ' ERROR ';
+function addTag(args) {
+    args.unshift('[Statsig]');
+    return args; // ['[Statsig]', ...args];
+}
+exports.LogLevel = {
+    None: 0,
+    Error: 1,
+    Warn: 2,
+    Info: 3,
+    Debug: 4,
+};
+class Log {
+    static info(...args) {
+        if (Log.level >= exports.LogLevel.Info) {
+            console.info(_INFO, ...addTag(args));
+        }
+    }
+    static debug(...args) {
+        if (Log.level >= exports.LogLevel.Debug) {
+            console.debug(DEBUG, ...addTag(args));
+        }
+    }
+    static warn(...args) {
+        if (Log.level >= exports.LogLevel.Warn) {
+            console.warn(_WARN, ...addTag(args));
+        }
+    }
+    static error(...args) {
+        if (Log.level >= exports.LogLevel.Error) {
+            console.error(ERROR, ...addTag(args));
+        }
+    }
+}
+exports.Log = Log;
+Log.level = exports.LogLevel.Warn;

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

@@ -0,0 +1,11 @@
+import { AnyEvaluationOptions } from './EvaluationOptions';
+export declare const MemoPrefix: {
+    readonly _gate: "g";
+    readonly _dynamicConfig: "c";
+    readonly _experiment: "e";
+    readonly _configList: "cl";
+    readonly _layer: "l";
+    readonly _paramStore: "p";
+};
+export type MemoPrefix = (typeof MemoPrefix)[keyof typeof MemoPrefix];
+export declare function createMemoKey(prefix: MemoPrefix, name: string, options?: AnyEvaluationOptions): string | undefined;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoKey = exports.MemoPrefix = void 0;
+exports.MemoPrefix = {
+    _gate: 'g',
+    _dynamicConfig: 'c',
+    _experiment: 'e',
+    _configList: 'cl',
+    _layer: 'l',
+    _paramStore: 'p',
+};
+const EXIST_KEYS = new Set([
+// Add keys that should be memoized based only on their existence, not their value
+]);
+const DO_NOT_MEMO_KEYS = new Set([
+    // Add keys that if exist, should not be memoized
+    'userPersistedValues',
+]);
+function createMemoKey(prefix, name, options) {
+    let cacheKey = `${prefix}|${name}`;
+    if (!options) {
+        return cacheKey;
+    }
+    for (const key of Object.keys(options)) {
+        if (DO_NOT_MEMO_KEYS.has(key)) {
+            return undefined;
+        }
+        if (EXIST_KEYS.has(key)) {
+            cacheKey += `|${key}=true`;
+        }
+        else {
+            cacheKey += `|${key}=${options[key]}`;
+        }
+    }
+    return cacheKey;
+}
+exports.createMemoKey = createMemoKey;

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

@@ -0,0 +1,26 @@
+export declare const Endpoint: {
+    readonly _initialize: "initialize";
+    readonly _rgstr: "rgstr";
+    readonly _download_config_specs: "download_config_specs";
+};
+export type Endpoint = (typeof Endpoint)[keyof typeof Endpoint];
+export declare const NetworkDefault: {
+    rgstr: "https://prodregistryv2.org/v1";
+    initialize: "https://featureassets.org/v1";
+    download_config_specs: "https://api.statsigcdn.com/v1";
+};
+export type NetworkPriority = 'high' | 'low' | 'auto';
+export type NetworkArgs = RequestInit & {
+    priority?: NetworkPriority;
+};
+export declare const NetworkParam: {
+    readonly EventCount: "ec";
+    readonly SdkKey: "k";
+    readonly SdkType: "st";
+    readonly SdkVersion: "sv";
+    readonly Time: "t";
+    readonly SessionID: "sid";
+    readonly StatsigEncoded: "se";
+    readonly IsGzipped: "gz";
+};
+export type NetworkParam = (typeof NetworkParam)[keyof typeof NetworkParam];

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkParam = exports.NetworkDefault = exports.Endpoint = void 0;
+exports.Endpoint = {
+    _initialize: 'initialize',
+    _rgstr: 'rgstr',
+    _download_config_specs: 'download_config_specs',
+};
+exports.NetworkDefault = {
+    [exports.Endpoint._rgstr]: 'https://prodregistryv2.org/v1',
+    [exports.Endpoint._initialize]: 'https://featureassets.org/v1',
+    [exports.Endpoint._download_config_specs]: 'https://api.statsigcdn.com/v1',
+};
+exports.NetworkParam = {
+    EventCount: 'ec',
+    SdkKey: 'k',
+    SdkType: 'st',
+    SdkVersion: 'sv',
+    Time: 't',
+    SessionID: 'sid',
+    StatsigEncoded: 'se',
+    IsGzipped: 'gz',
+};