pi-cursor-sdk 0.1.1 → 0.1.3

package/node_modules/@statsig/client-core/src/StatsigOptionsCommon.d.ts

@@ -0,0 +1,180 @@
+import { LogLevel } from './Log';
+import { NetworkArgs } from './NetworkConfig';
+import { OverrideAdapter } from './OverrideAdapter';
+import { StorageProvider } from './StorageProvider';
+/** Options that can be set at init and updated during runtime. */
+export type StatsigRuntimeMutableOptions = {
+    /**
+     * Prevents sending any events over the network.
+     * @deprecated Set {@link StatsigRuntimeMutableOptions.loggingEnabled} to "disabled" instead
+     */
+    disableLogging?: boolean;
+    /**
+     * Controls when to enable or disable logging:
+     * - "disabled": Prevents sending any events over the network.
+     * - "browser-only": Only sends events in browser environments.
+     * - "always": Skip browser checks and always logs events
+     *
+     * @default "browser-only"
+     */
+    loggingEnabled?: LoggingEnabledOption;
+    /**
+     * Prevents writing anything to storage.
+     *
+     * Note: caching will not work if storage is disabled
+     */
+    disableStorage?: boolean;
+    /**
+     * @deprecated Use `logEventCompressionMode` instead.
+     * Whether or not Statsig should compress JSON bodies for network requests where possible.
+     *
+     * default: `false`
+     */
+    disableCompression?: boolean;
+    /**
+     * Opt in cookie usage.
+     */
+    enableCookies?: boolean;
+    /**
+     * Controls JSON body compression for network requests.
+     * - `disabled`: Never compress
+     * - `enabled`: Compress unless using a proxy
+     * - `forced`: Always compress, even with a proxy
+     *
+     * default: `enabled`
+     */
+    logEventCompressionMode?: LogEventCompressionMode;
+};
+export type NetworkConfigCommon = {
+    /**
+     * The API to use for all SDK network requests. You should not need to override this
+     * unless you have a custom API that implements the Statsig endpoints.
+     */
+    api?: string;
+    /**
+     * The URL used to flush queued events via a POST request. Takes precedence over {@link StatsigOptionsCommon.api}.
+     *
+     * default: `https://prodregistryv2.org/v1/rgstr`
+     */
+    logEventUrl?: string;
+    /**
+     * A list of URLs to try if the primary logEventUrl fails.
+     */
+    logEventFallbackUrls?: string[];
+    /**
+     * 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}
+     */
+    networkOverrideFunc?: (url: string, args: NetworkArgs) => Promise<Response>;
+    /**
+     * The maximum amount of time (in milliseconds) that any network request can take
+     * before timing out.
+     *
+     * default: `10,000 ms` (10 seconds)
+     */
+    networkTimeoutMs?: number;
+    /**
+     * Intended for testing purposes. Prevents any network requests being made.
+     */
+    preventAllNetworkTraffic?: boolean;
+};
+/** Options for configuring a Statsig client. */
+export type StatsigOptionsCommon<NetworkConfig extends NetworkConfigCommon> = StatsigRuntimeMutableOptions & {
+    /**
+     * When true, the SDK will not generate a stableID for the user. Useful when bootstrapping from a server without a StableID.
+     *
+     * default: `false`
+     */
+    disableStableID?: boolean;
+    /**
+     * Whether or not Statsig should use raw JSON for network requests where possible.
+     *
+     * default: `false`
+     */
+    disableStatsigEncoding?: boolean;
+    /**
+     * An object you can use to set environment variables that apply to all of your users
+     * in the same session.
+     */
+    environment?: StatsigEnvironment;
+    /**
+     * (Web only) Should the 'current page' url be included with logged events.
+     *
+     * default: true
+     */
+    includeCurrentPageUrlWithEvents?: boolean;
+    /**
+     * 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`
+     */
+    loggingBufferMaxSize?: number;
+    /**
+     * How often (in milliseconds) to flush logs to Statsig.
+     *
+     * default: `10,000 ms` (10 seconds)
+     */
+    loggingIntervalMs?: number;
+    /**
+     * Allows for fine grained control over which api or urls are hit for specific Statsig network requests.
+     *
+     * For defaults see {@link StatsigClientUrlOverrideOptions}
+     */
+    networkConfig?: NetworkConfig;
+    /**
+     * An implementor of {@link OverrideAdapter}, used to alter evaluations before its
+     * returned to the caller of a check api (checkGate/getExperiment etc).
+     */
+    overrideAdapter?: OverrideAdapter;
+    /**
+     * Overrides the auto-generated SessionID with the provided string.
+     *
+     * Note: Sessions still expire and will be replaced with an auto-generated SessionID.
+     */
+    initialSessionID?: string;
+    /**
+     * Swaps out the storage layer used by the SDK.
+     *
+     * default: `window.localStorage` on Web. `@react-native-async-storage/async-storage` on Mobile.
+     */
+    storageProvider?: StorageProvider;
+    /**
+     * Disables all memoization of the core evaluation functions.
+     *
+     * default: `false`
+     */
+    disableEvaluationMemoization?: boolean;
+};
+export type AnyStatsigOptions = StatsigOptionsCommon<NetworkConfigCommon>;
+export type StatsigEnvironment = {
+    tier?: string;
+    [key: string]: string | undefined;
+};
+export declare const LogEventCompressionMode: {
+    /** Do not compress request bodies */
+    readonly Disabled: "d";
+    /** Compress request bodies unless a network proxy is configured */
+    readonly Enabled: "e";
+    /** Always compress request bodies, even when a proxy is configured */
+    readonly Forced: "f";
+};
+export type LogEventCompressionMode = (typeof LogEventCompressionMode)[keyof typeof LogEventCompressionMode];
+export declare const LoggingEnabledOption: {
+    readonly disabled: "disabled";
+    readonly browserOnly: "browser-only";
+    readonly always: "always";
+};
+export type LoggingEnabledOption = (typeof LoggingEnabledOption)[keyof typeof LoggingEnabledOption];

package/node_modules/@statsig/client-core/src/StatsigOptionsCommon.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggingEnabledOption = exports.LogEventCompressionMode = void 0;
+exports.LogEventCompressionMode = {
+    /** Do not compress request bodies */
+    Disabled: 'd',
+    /** Compress request bodies unless a network proxy is configured */
+    Enabled: 'e',
+    /** Always compress request bodies, even when a proxy is configured */
+    Forced: 'f',
+};
+exports.LoggingEnabledOption = {
+    disabled: 'disabled',
+    browserOnly: 'browser-only',
+    always: 'always',
+};

package/node_modules/@statsig/client-core/src/StatsigPlugin.d.ts

@@ -0,0 +1,5 @@
+import { StatsigClientInterface } from './ClientInterfaces';
+export type StatsigPlugin<T extends StatsigClientInterface> = {
+    readonly __plugin: 'session-replay' | 'auto-capture' | 'triggered-session-replay' | 'cli-session-replay-node' | (string & {});
+    bind: (client: T) => void;
+};

package/node_modules/@statsig/client-core/src/StatsigPlugin.js

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

package/node_modules/@statsig/client-core/src/StatsigTypeFactories.d.ts

@@ -0,0 +1,8 @@
+import { DynamicConfigEvaluation, EvaluationDetails, GateEvaluation, LayerEvaluation } from './EvaluationTypes';
+import { AnyConfigBasedStatsigType, DynamicConfig, Experiment, FeatureGate, Layer, TypedGet } 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 _makeExperiment(name: string, details: EvaluationDetails, evaluation: DynamicConfigEvaluation | null): Experiment;
+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;
+export declare function _makeTypedGet(name: string, value: Record<string, unknown> | undefined, exposeFunc?: (param: string) => void): TypedGet;

package/node_modules/@statsig/client-core/src/StatsigTypeFactories.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._makeTypedGet = exports._mergeOverride = exports._makeLayer = exports._makeExperiment = exports._makeDynamicConfig = exports._makeFeatureGate = void 0;
+const Log_1 = require("./Log");
+const TypingUtils_1 = require("./TypingUtils");
+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 : '',
+        __evaluation: evaluation,
+        value,
+    };
+}
+function _makeFeatureGate(name, details, evaluation) {
+    var _a;
+    return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, (evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) === true)), { idType: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.id_type) !== null && _a !== void 0 ? _a : null });
+}
+exports._makeFeatureGate = _makeFeatureGate;
+function _makeDynamicConfig(name, details, evaluation) {
+    var _a, _b;
+    const value = (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) !== null && _a !== void 0 ? _a : {};
+    return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, value)), { idType: (_b = evaluation === null || evaluation === void 0 ? void 0 : evaluation.id_type) !== null && _b !== void 0 ? _b : null, get: _makeTypedGet(name, evaluation === null || evaluation === void 0 ? void 0 : evaluation.value) });
+}
+exports._makeDynamicConfig = _makeDynamicConfig;
+function _makeExperiment(name, details, evaluation) {
+    var _a;
+    const result = _makeDynamicConfig(name, details, evaluation);
+    return Object.assign(Object.assign({}, result), { groupName: (_a = evaluation === null || evaluation === void 0 ? void 0 : evaluation.group_name) !== null && _a !== void 0 ? _a : null });
+}
+exports._makeExperiment = _makeExperiment;
+function _makeLayer(name, details, evaluation, exposeFunc) {
+    var _a, _b;
+    return Object.assign(Object.assign({}, _makeEvaluation(name, details, evaluation, undefined)), { get: _makeTypedGet(name, 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(original.name, value, exposeFunc) });
+}
+exports._mergeOverride = _mergeOverride;
+function _makeTypedGet(name, 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 && !(0, TypingUtils_1._isTypeMatch)(found, fallback)) {
+            Log_1.Log.warn(`Parameter type mismatch. '${name}.${param}' was found to be type '${typeof found}' but fallback/return type is '${typeof fallback}'. See https://docs.statsig.com/client/javascript-sdk/#typed-getters`);
+            return (fallback !== null && fallback !== void 0 ? fallback : null);
+        }
+        exposeFunc === null || exposeFunc === void 0 ? void 0 : exposeFunc(param);
+        return found;
+    };
+}
+exports._makeTypedGet = _makeTypedGet;

package/node_modules/@statsig/client-core/src/StatsigTypes.d.ts

@@ -0,0 +1,43 @@
+import { EvaluationDetails, ExperimentEvaluation, GateEvaluation, LayerEvaluation } from './EvaluationTypes';
+import { ParamStoreConfig } from './ParamStoreTypes';
+import { Flatten } from './TypingUtils';
+export type TypedGet = <T = unknown>(key: string, fallback?: T) => TypedReturn<T>;
+export type ParamStoreTypedGet = <T = unknown>(key: string, fallback: T) => 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;
+    readonly value: boolean;
+    readonly idType: string | null;
+    readonly __evaluation: GateEvaluation | null;
+}>;
+export type Experiment = Flatten<{
+    readonly name: string;
+    readonly ruleID: string;
+    readonly details: EvaluationDetails;
+    readonly value: Record<string, unknown>;
+    readonly groupName: string | null;
+    readonly idType: string | null;
+    readonly __evaluation: ExperimentEvaluation | null;
+    readonly get: TypedGet;
+}>;
+export type DynamicConfig = Flatten<Omit<Experiment, 'groupName'>>;
+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;
+    get: TypedGet;
+}>;
+export type ParameterStore = Flatten<{
+    readonly name: string;
+    readonly details: EvaluationDetails;
+    readonly get: TypedGet;
+    readonly __configuration: ParamStoreConfig | null;
+}>;
+export type AnyConfigBasedStatsigType = DynamicConfig | Experiment | Layer;
+export type AnyStatsigType = FeatureGate | AnyConfigBasedStatsigType | ParameterStore;

package/node_modules/@statsig/client-core/src/StatsigTypes.js

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

package/node_modules/@statsig/client-core/src/StatsigUpdateDetails.d.ts

@@ -0,0 +1,14 @@
+import { StatsigWarnings } from './EvaluationTypes';
+import { DataSource } from './StatsigDataAdapter';
+export type StatsigUpdateDetails = {
+    duration: number;
+    source: DataSource;
+    success: boolean;
+    error: Error | null;
+    sourceUrl: string | null;
+    warnings?: StatsigWarnings[];
+};
+export declare const createUpdateDetails: (success: boolean, source: DataSource, initDuration: number, error: Error | null, sourceUrl: string | null, warnings?: StatsigWarnings[]) => StatsigUpdateDetails;
+export declare const UPDATE_DETAIL_ERROR_MESSAGES: {
+    NO_NETWORK_DATA: string;
+};

package/node_modules/@statsig/client-core/src/StatsigUpdateDetails.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_DETAIL_ERROR_MESSAGES = exports.createUpdateDetails = void 0;
+const createUpdateDetails = (success, source, initDuration, error, sourceUrl, warnings) => {
+    return {
+        duration: initDuration,
+        source,
+        success,
+        error,
+        sourceUrl,
+        warnings,
+    };
+};
+exports.createUpdateDetails = createUpdateDetails;
+exports.UPDATE_DETAIL_ERROR_MESSAGES = {
+    NO_NETWORK_DATA: 'No data was returned from the network. This may be due to a network timeout if a timeout value was specified in the options or ad blocker error.',
+};

package/node_modules/@statsig/client-core/src/StatsigUser.d.ts

@@ -0,0 +1,24 @@
+import type { AnyStatsigOptions, StatsigEnvironment } from './StatsigOptionsCommon';
+type StatsigUserPrimitives = string | number | boolean | Array<string> | undefined;
+export type StatsigUser = {
+    userID?: string;
+    customIDs?: {
+        [key: string]: string | undefined;
+        stableID?: string;
+    };
+    email?: string;
+    ip?: string;
+    userAgent?: string;
+    country?: string;
+    locale?: string;
+    appVersion?: string;
+    custom?: Record<string, StatsigUserPrimitives>;
+    privateAttributes?: Record<string, StatsigUserPrimitives> | null;
+    analyticsOnlyMetadata?: Record<string, string | number | boolean>;
+};
+export type StatsigUserInternal = StatsigUser & {
+    statsigEnvironment: StatsigEnvironment | undefined;
+};
+export declare function _normalizeUser(original: StatsigUser, options?: AnyStatsigOptions | null, fallbackEnvironment?: string | null): StatsigUserInternal;
+export declare function _getFullUserHash(user: StatsigUser | undefined): string | null;
+export {};

package/node_modules/@statsig/client-core/src/StatsigUser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._getFullUserHash = exports._normalizeUser = void 0;
+const Hashing_1 = require("./Hashing");
+const Log_1 = require("./Log");
+const SafeJs_1 = require("./SafeJs");
+function _normalizeUser(original, options, fallbackEnvironment) {
+    const copy = (0, SafeJs_1._cloneObject)('StatsigUser', original);
+    if (copy == null) {
+        Log_1.Log.error('Failed to clone user');
+        return { statsigEnvironment: undefined };
+    }
+    if (options != null && options.environment != null) {
+        copy.statsigEnvironment = options.environment;
+    }
+    else if (fallbackEnvironment != null) {
+        copy.statsigEnvironment = { tier: fallbackEnvironment };
+    }
+    return copy;
+}
+exports._normalizeUser = _normalizeUser;
+function _getFullUserHash(user) {
+    return user ? (0, Hashing_1._DJB2Object)(user) : null;
+}
+exports._getFullUserHash = _getFullUserHash;

package/node_modules/@statsig/client-core/src/StorageProvider.d.ts

@@ -0,0 +1,17 @@
+export type StorageProvider = {
+    isReady: () => boolean;
+    isReadyResolver: () => Promise<void> | null;
+    getProviderName: () => string;
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+    getAllKeys: () => readonly string[];
+};
+type StorageProviderManagment = {
+    _setProvider: (newProvider: StorageProvider) => void;
+    _setDisabled: (isDisabled: boolean) => void;
+};
+export declare const Storage: StorageProvider & StorageProviderManagment;
+export declare function _getObjectFromStorage<T>(key: string): T | null;
+export declare function _setObjectInStorage(key: string, obj: unknown): void;
+export {};

package/node_modules/@statsig/client-core/src/StorageProvider.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._setObjectInStorage = exports._getObjectFromStorage = exports.Storage = void 0;
+const Log_1 = require("./Log");
+const SafeJs_1 = require("./SafeJs");
+const inMemoryStore = {};
+const _inMemoryProvider = {
+    isReady: () => true,
+    isReadyResolver: () => null,
+    getProviderName: () => 'InMemory',
+    getItem: (key) => inMemoryStore[key] ? inMemoryStore[key] : null,
+    setItem: (key, value) => {
+        inMemoryStore[key] = value;
+    },
+    removeItem: (key) => {
+        delete inMemoryStore[key];
+    },
+    getAllKeys: () => Object.keys(inMemoryStore),
+};
+let _localStorageProvider = null;
+try {
+    const win = (0, SafeJs_1._getWindowSafe)();
+    if (win &&
+        win.localStorage &&
+        typeof win.localStorage.getItem === 'function') {
+        _localStorageProvider = {
+            isReady: () => true,
+            isReadyResolver: () => null,
+            getProviderName: () => 'LocalStorage',
+            getItem: (key) => win.localStorage.getItem(key),
+            setItem: (key, value) => win.localStorage.setItem(key, value),
+            removeItem: (key) => win.localStorage.removeItem(key),
+            getAllKeys: () => Object.keys(win.localStorage),
+        };
+    }
+}
+catch (error) {
+    Log_1.Log.warn('Failed to setup localStorageProvider.');
+}
+let _main = _localStorageProvider !== null && _localStorageProvider !== void 0 ? _localStorageProvider : _inMemoryProvider;
+let _current = _main;
+function _inMemoryBreaker(action) {
+    try {
+        return action();
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'SecurityError') {
+            exports.Storage._setProvider(_inMemoryProvider);
+            return null;
+        }
+        throw error;
+    }
+}
+exports.Storage = {
+    isReady: () => _current.isReady(),
+    isReadyResolver: () => _current.isReadyResolver(),
+    getProviderName: () => _current.getProviderName(),
+    getItem: (key) => _inMemoryBreaker(() => _current.getItem(key)),
+    setItem: (key, value) => _inMemoryBreaker(() => _current.setItem(key, value)),
+    removeItem: (key) => _current.removeItem(key),
+    getAllKeys: () => _current.getAllKeys(),
+    // StorageProviderManagment
+    _setProvider: (newProvider) => {
+        _main = newProvider;
+        _current = newProvider;
+    },
+    _setDisabled: (isDisabled) => {
+        if (isDisabled) {
+            _current = _inMemoryProvider;
+        }
+        else {
+            _current = _main;
+        }
+    },
+};
+function _getObjectFromStorage(key) {
+    const value = exports.Storage.getItem(key);
+    try {
+        return JSON.parse(value !== null && value !== void 0 ? value : 'null');
+    }
+    catch (e) {
+        Log_1.Log.error(`Failed to parse value for key "${key}"`);
+        return null;
+    }
+}
+exports._getObjectFromStorage = _getObjectFromStorage;
+function _setObjectInStorage(key, obj) {
+    exports.Storage.setItem(key, JSON.stringify(obj));
+}
+exports._setObjectInStorage = _setObjectInStorage;

package/node_modules/@statsig/client-core/src/TypedJsonParse.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {string} data The values to parse into T
+ * @param {string} guard A field that must exists on the parsed object for the parse to be valid
+ * @param {string} error An error to print via Log.error() when parsing fails
+ * @returns {T | null} The parse object T or null if it failed
+ */
+export declare function _typedJsonParse<T>(data: string, guard: string, typeName: string): T | null;

package/node_modules/@statsig/client-core/src/TypedJsonParse.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typedJsonParse = void 0;
+const Log_1 = require("./Log");
+/**
+ *
+ * @param {string} data The values to parse into T
+ * @param {string} guard A field that must exists on the parsed object for the parse to be valid
+ * @param {string} error An error to print via Log.error() when parsing fails
+ * @returns {T | null} The parse object T or null if it failed
+ */
+function _typedJsonParse(data, guard, typeName) {
+    try {
+        const result = JSON.parse(data);
+        if (result &&
+            typeof result === 'object' &&
+            guard in result) {
+            return result;
+        }
+    }
+    catch (_a) {
+        // noop
+    }
+    Log_1.Log.error(`Failed to parse ${typeName}`);
+    return null;
+}
+exports._typedJsonParse = _typedJsonParse;

package/node_modules/@statsig/client-core/src/TypingUtils.d.ts

@@ -0,0 +1,7 @@
+type Primitive = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function';
+export type Flatten<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export declare function _typeOf(input: unknown): Primitive | 'array';
+export declare function _isTypeMatch<T>(a: unknown, b: unknown): a is T;
+export {};

package/node_modules/@statsig/client-core/src/TypingUtils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._isTypeMatch = exports._typeOf = void 0;
+function _typeOf(input) {
+    return Array.isArray(input) ? 'array' : typeof input;
+}
+exports._typeOf = _typeOf;
+function _isTypeMatch(a, b) {
+    const typeOf = (x) => Array.isArray(x) ? 'array' : x === null ? 'null' : typeof x;
+    return typeOf(a) === typeOf(b);
+}
+exports._isTypeMatch = _isTypeMatch;

package/node_modules/@statsig/client-core/src/UUID.d.ts

@@ -0,0 +1 @@
+export declare function getUUID(): string;

package/node_modules/@statsig/client-core/src/UUID.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUUID = void 0;
+function getUUID() {
+    if (typeof crypto !== 'undefined' &&
+        typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    let d = new Date().getTime();
+    let d2 = (typeof performance !== 'undefined' &&
+        performance.now &&
+        performance.now() * 1000) ||
+        0;
+    const y = '89ab'[Math.floor(Math.random() * 4)];
+    return `xxxxxxxx-xxxx-4xxx-${y}xxx-xxxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+        let r = Math.random() * 16;
+        if (d > 0) {
+            r = (d + r) % 16 | 0;
+            d = Math.floor(d / 16);
+        }
+        else {
+            r = (d2 + r) % 16 | 0;
+            d2 = Math.floor(d2 / 16);
+        }
+        return (c === 'x' ? r : (r & 0x7) | 0x8).toString(16);
+    });
+}
+exports.getUUID = getUUID;

package/node_modules/@statsig/client-core/src/UrlConfiguration.d.ts

@@ -0,0 +1,12 @@
+import { Endpoint } from './NetworkConfig';
+export type EndpointDnsKey = 'i' | 'e' | 'd';
+export declare class UrlConfiguration {
+    readonly endpoint: Endpoint;
+    readonly endpointDnsKey: EndpointDnsKey;
+    readonly defaultUrl: string;
+    readonly customUrl: string | null;
+    readonly fallbackUrls: string[] | null;
+    constructor(endpoint: Endpoint, customUrl: string | undefined | null, customApi: string | undefined | null, fallbackUrls: string[] | undefined | null);
+    getUrl(): string;
+    getChecksum(): string;
+}

package/node_modules/@statsig/client-core/src/UrlConfiguration.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlConfiguration = void 0;
+const Hashing_1 = require("./Hashing");
+const NetworkConfig_1 = require("./NetworkConfig");
+const ENDPOINT_DNS_KEY_MAP = {
+    [NetworkConfig_1.Endpoint._initialize]: 'i',
+    [NetworkConfig_1.Endpoint._rgstr]: 'e',
+    [NetworkConfig_1.Endpoint._download_config_specs]: 'd',
+};
+class UrlConfiguration {
+    constructor(endpoint, customUrl, customApi, fallbackUrls) {
+        this.customUrl = null;
+        this.fallbackUrls = null;
+        this.endpoint = endpoint;
+        this.endpointDnsKey = ENDPOINT_DNS_KEY_MAP[endpoint];
+        if (customUrl) {
+            this.customUrl = customUrl;
+        }
+        if (!customUrl && customApi) {
+            this.customUrl = customApi.endsWith('/')
+                ? `${customApi}${endpoint}`
+                : `${customApi}/${endpoint}`;
+        }
+        if (fallbackUrls) {
+            this.fallbackUrls = fallbackUrls;
+        }
+        const defaultApi = NetworkConfig_1.NetworkDefault[endpoint];
+        this.defaultUrl = `${defaultApi}/${endpoint}`;
+    }
+    getUrl() {
+        var _a;
+        return (_a = this.customUrl) !== null && _a !== void 0 ? _a : this.defaultUrl;
+    }
+    getChecksum() {
+        var _a;
+        const fallbacks = ((_a = this.fallbackUrls) !== null && _a !== void 0 ? _a : []).sort().join(',');
+        return (0, Hashing_1._DJB2)(this.customUrl + fallbacks);
+    }
+}
+exports.UrlConfiguration = UrlConfiguration;