react-native-featureflags 0.1.0

package/dist/client.js

@@ -0,0 +1,707 @@
+import { FetchTransport, createAnonymousId, createDefaultLogger, evaluateBooleanFlag, evaluateFlagValue, getFlagPayload, indexFlags, loadCachedSnapshot, maskApiKey, persistCachedSnapshot, toAnonymousUser, validatePublicApiKey, withRetry, withTimeout, } from './internal/core.js';
+import { FlagsStore } from './store.js';
+import { memoryStorage } from './storage.js';
+const ANON_ID_KEY = 'betsy:rn:anon-id';
+const USER_CACHE_KEY = 'betsy:rn:user';
+const SNAPSHOT_KEY = 'betsy:rn:snapshot';
+const RELAY_BASE_URL = 'https://8nknkmxt07.execute-api.us-east-1.amazonaws.com/';
+const DEFAULT_STREAM_URL = 'wss://hkst7yd32k.execute-api.us-east-1.amazonaws.com/prod';
+const DEFAULT_CACHE_TTL_MS = 5 * 60_000;
+const DEFAULT_POLL_MS = 60_000;
+const DEFAULT_TIMEOUT_MS = 6_000;
+const DEFAULT_TELEMETRY_FLUSH_MS = 10_000;
+const DEFAULT_TELEMETRY_BATCH_SIZE = 50;
+const DEFAULT_STREAM_RECONNECT_MS = 2_000;
+const BLOCKED_ATTRIBUTE_KEYS = new Set([
+    'projectID',
+    'id',
+    'environmentID',
+    'currentUserID',
+    'deviceID',
+    'tenantGroup',
+    'isAnonymous',
+    'anonymousID',
+    'firstSeenAt',
+    'lastSeenAt',
+    'userAttributes',
+]);
+export class ReactNativeFlagsClient {
+    store = new FlagsStore();
+    sdkSource = "react-native";
+    pollTimer;
+    telemetryTimer;
+    config;
+    requestSequence = 0;
+    anonymousDeviceId;
+    attributesByUserId = new Map();
+    offlineFallbackFlags = {};
+    telemetryQueue = [];
+    exposureKeys = new Set();
+    assignmentKeys = new Set();
+    readEvaluationKeys = new Set();
+    streamSocket;
+    streamReconnectTimer;
+    latestConfigVersion;
+    configureSignature;
+    configureInFlight;
+    subscribe = (callback) => this.store.subscribe(callback);
+    getState = () => this.store.getState();
+    async configure(options) {
+        const signature = this.buildConfigureSignature(options);
+        if (this.configureInFlight && this.configureSignature === signature) {
+            return this.configureInFlight;
+        }
+        if (this.store.getState().configured && this.configureSignature === signature) {
+            return;
+        }
+        const configureTask = this.configureInternal(options, signature);
+        this.configureInFlight = configureTask;
+        return configureTask.finally(() => {
+            if (this.configureInFlight === configureTask) {
+                this.configureInFlight = undefined;
+            }
+        });
+    }
+    async configureInternal(options, signature) {
+        validatePublicApiKey(options.apiKey);
+        this.stopStreaming();
+        this.stopPolling();
+        this.configureSignature = signature;
+        this.config = options;
+        const logger = options.logger ?? createDefaultLogger(false);
+        logger.info('Configuring Betsy RN SDK', { apiKey: maskApiKey(options.apiKey) });
+        const storage = options.storage ?? memoryStorage;
+        this.anonymousDeviceId = (await storage.getItem(ANON_ID_KEY)) ?? undefined;
+        const cachedUser = await this.loadCachedUser(storage);
+        const user = this.normalizeUser(options.user ?? cachedUser ?? (await this.resolveAnonymousUser(storage)));
+        await this.persistCachedUser(storage, user);
+        await this.ensureAnonymousDeviceId(storage, user);
+        const cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+        const cachedSnapshot = await loadCachedSnapshot(storage, SNAPSHOT_KEY, cacheTtlMs);
+        this.offlineFallbackFlags = indexFlags(cachedSnapshot?.offlineFallbackFlags ?? []);
+        const initialState = {
+            configured: true,
+            ready: Boolean(cachedSnapshot),
+            apiKey: options.apiKey,
+            user,
+            flags: indexFlags(cachedSnapshot?.flags ?? []),
+        };
+        if (cachedSnapshot?.fetchedAt !== undefined) {
+            initialState.lastFetchAt = cachedSnapshot.fetchedAt;
+        }
+        this.store.setState(initialState);
+        this.latestConfigVersion = undefined;
+        this.exposureKeys.clear();
+        this.assignmentKeys.clear();
+        this.readEvaluationKeys.clear();
+        this.clearError();
+        await this.refresh();
+        this.startStreamOrPolling();
+        this.startTelemetryFlush();
+    }
+    async login(user) {
+        this.requireConfigured();
+        const nextUser = this.mergeUser(user);
+        this.store.patch({ user: nextUser });
+        this.exposureKeys.clear();
+        this.assignmentKeys.clear();
+        this.readEvaluationKeys.clear();
+        await this.persistCachedUser(this.getStorage(), nextUser);
+        await this.refresh();
+    }
+    async setAttributes(attributes) {
+        this.requireConfigured();
+        const currentUser = this.getUser();
+        const nextUser = this.mergeUser({ id: currentUser.id, attributes });
+        this.store.patch({ user: nextUser });
+        this.exposureKeys.clear();
+        this.assignmentKeys.clear();
+        this.readEvaluationKeys.clear();
+        await this.persistCachedUser(this.getStorage(), nextUser);
+        await this.refresh();
+    }
+    async identify(user) {
+        await this.login(user);
+    }
+    async logout() {
+        this.requireConfigured();
+        const storage = this.getStorage();
+        await this.ensureAnonymousDeviceId(storage, this.getUser());
+        const user = this.normalizeUser(toAnonymousUser(createAnonymousId()));
+        this.store.patch({ user });
+        this.exposureKeys.clear();
+        this.assignmentKeys.clear();
+        this.readEvaluationKeys.clear();
+        await this.persistCachedUser(storage, user);
+        await this.refresh();
+    }
+    async refresh() {
+        this.requireConfigured();
+        const config = this.config;
+        const logger = config.logger ?? createDefaultLogger(false);
+        const storage = this.getStorage();
+        const sequence = ++this.requestSequence;
+        try {
+            const snapshot = await withRetry(async () => {
+                return withTimeout(config.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS, async (signal) => {
+                    const activeUser = this.getUser();
+                    const query = {
+                        userId: activeUser.id,
+                    };
+                    const userAttributes = activeUser.attributes ?? this.attributesByUserId.get(activeUser.id);
+                    if (userAttributes) {
+                        query.userAttributes = JSON.stringify(userAttributes);
+                    }
+                    if (this.anonymousDeviceId) {
+                        query.anonymousId = this.anonymousDeviceId;
+                    }
+                    const response = await this.getTransport().get('/v1/flags', {
+                        apiKey: config.apiKey,
+                        signal,
+                        query,
+                    });
+                    const typed = response;
+                    const meta = response.meta;
+                    const offlineFallbackFlags = this.extractOfflineFallbackFlags(typed.flags ?? []);
+                    const configVersion = typeof meta?.configVersion === 'string' ? meta.configVersion : undefined;
+                    const now = Date.now();
+                    return {
+                        flags: typed.flags ?? [],
+                        fetchedAt: now,
+                        offlineFallbackFlags: Object.values(offlineFallbackFlags),
+                        configVersion,
+                    };
+                });
+            });
+            if (sequence !== this.requestSequence)
+                return;
+            const nextFlags = indexFlags(snapshot.flags);
+            this.offlineFallbackFlags = indexFlags(snapshot.offlineFallbackFlags ?? []);
+            this.store.patch({
+                flags: nextFlags,
+                lastFetchAt: snapshot.fetchedAt,
+                ready: true,
+            });
+            this.latestConfigVersion = snapshot.configVersion;
+            this.enqueueAssignmentEvents(snapshot.flags);
+            this.clearError();
+            await persistCachedSnapshot(storage, SNAPSHOT_KEY, snapshot);
+        }
+        catch (error) {
+            logger.error('Betsy refresh failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            this.store.patch({
+                error: error instanceof Error ? error.message : 'Unknown refresh error',
+            });
+            if (Object.keys(this.offlineFallbackFlags).length > 0) {
+                this.store.patch({
+                    flags: this.offlineFallbackFlags,
+                    ready: true,
+                });
+            }
+            else if (Object.keys(this.store.getState().flags).length > 0) {
+                this.store.patch({ ready: true });
+            }
+        }
+    }
+    async track(eventName, properties, options) {
+        this.requireConfigured();
+        if (!eventName || !eventName.trim())
+            return;
+        const user = this.getUser();
+        this.enqueueTelemetryEvent({
+            name: eventName.trim(),
+            timestamp: new Date().toISOString(),
+            userId: user.id,
+            anonymousId: this.anonymousDeviceId,
+            userAttributes: user.attributes ?? this.attributesByUserId.get(user.id),
+            properties: properties ?? {},
+        }, 'track');
+        const maxBatch = this.config?.telemetryBatchSize ?? DEFAULT_TELEMETRY_BATCH_SIZE;
+        if (options?.immediate || this.telemetryQueue.length >= maxBatch) {
+            await this.flushTelemetry();
+        }
+    }
+    async expose(flagKey, options) {
+        this.requireConfigured();
+        const flag = this.store.getState().flags[flagKey];
+        if (!flag)
+            return;
+        await this.enqueueExposure(flag, options);
+    }
+    notifyFlagRead(flagKey) {
+        const state = this.store.getState();
+        if (!state.ready)
+            return;
+        const flag = state.flags[flagKey];
+        if (!flag)
+            return;
+        this.enqueueReadEvaluationEvents(flag);
+        void this.enqueueExposure(flag);
+    }
+    getFlag(key, defaultValue = false) {
+        return evaluateBooleanFlag(this.store.getState().flags, key, defaultValue);
+    }
+    getFeatureFlagValue(key, defaultValue) {
+        return evaluateFlagValue(this.store.getState().flags, key, defaultValue);
+    }
+    getFeatureFlagPayload(key) {
+        return getFlagPayload(this.store.getState().flags, key);
+    }
+    getAllFlags() {
+        const output = {};
+        for (const [key, flag] of Object.entries(this.store.getState().flags)) {
+            this.enqueueReadEvaluationEvents(flag);
+            void this.enqueueExposure(flag);
+            output[key] = flag.value;
+        }
+        return output;
+    }
+    isReady() {
+        return this.store.getState().ready;
+    }
+    destroy() {
+        this.stopPolling();
+        if (this.telemetryTimer)
+            clearTimeout(this.telemetryTimer);
+        this.stopStreaming();
+    }
+    getStorage() {
+        return this.config?.storage ?? memoryStorage;
+    }
+    getUser() {
+        const user = this.store.getState().user;
+        if (!user) {
+            throw new Error('SDK has no active user identity');
+        }
+        return user;
+    }
+    getTransport() {
+        const config = this.config;
+        return new FetchTransport(RELAY_BASE_URL, config.fetchFn);
+    }
+    enqueueTelemetryEvent(event, reason) {
+        this.telemetryQueue.push(event);
+        const logger = this.config?.logger ?? createDefaultLogger(false);
+        const eventName = typeof event.name === 'string' ? event.name : 'unknown';
+        const properties = event.properties && typeof event.properties === 'object' && !Array.isArray(event.properties)
+            ? event.properties
+            : undefined;
+        logger.debug('Betsy telemetry queued', {
+            reason,
+            eventName,
+            queueSize: this.telemetryQueue.length,
+            userId: typeof event.userId === 'string' ? event.userId : undefined,
+            flagKey: typeof properties?.flagKey === 'string' ? properties.flagKey : undefined,
+        });
+    }
+    buildConfigureSignature(options) {
+        const attrs = options.user?.attributes;
+        const normalizedAttrs = attrs && typeof attrs === 'object'
+            ? Object.keys(attrs)
+                .sort()
+                .map((key) => [key, attrs[key]])
+            : [];
+        return JSON.stringify({
+            apiKey: options.apiKey,
+            userId: options.user?.id ?? '',
+            userAttributes: normalizedAttrs,
+            cacheTtlMs: options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
+            pollingIntervalMs: options.pollingIntervalMs ?? DEFAULT_POLL_MS,
+            requestTimeoutMs: options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+            streamEnabled: options.streamEnabled ?? true,
+            streamUrl: options.streamUrl ?? '',
+            telemetryEnabled: options.telemetryEnabled ?? true,
+            telemetryFlushIntervalMs: options.telemetryFlushIntervalMs ?? DEFAULT_TELEMETRY_FLUSH_MS,
+            telemetryBatchSize: options.telemetryBatchSize ?? DEFAULT_TELEMETRY_BATCH_SIZE,
+        });
+    }
+    requireConfigured() {
+        if (!this.config || !this.store.getState().configured) {
+            throw new Error('Flags.configure must be called before this operation');
+        }
+    }
+    async resolveAnonymousUser(storage) {
+        const existing = await storage.getItem(ANON_ID_KEY);
+        if (existing) {
+            this.anonymousDeviceId = existing;
+            return toAnonymousUser(existing);
+        }
+        const next = createAnonymousId();
+        await storage.setItem(ANON_ID_KEY, next);
+        this.anonymousDeviceId = next;
+        return toAnonymousUser(next);
+    }
+    async ensureAnonymousDeviceId(storage, user) {
+        if (this.anonymousDeviceId)
+            return;
+        const persisted = await storage.getItem(ANON_ID_KEY);
+        if (persisted) {
+            this.anonymousDeviceId = persisted;
+            return;
+        }
+        const deviceId = user.id.startsWith('anon_') ? user.id : createAnonymousId();
+        this.anonymousDeviceId = deviceId;
+        await storage.setItem(ANON_ID_KEY, deviceId);
+    }
+    async loadCachedUser(storage) {
+        const raw = await storage.getItem(USER_CACHE_KEY);
+        if (!raw)
+            return undefined;
+        try {
+            const parsed = this.normalizeUser(JSON.parse(raw));
+            if (!parsed?.id || typeof parsed.id !== 'string')
+                return undefined;
+            return parsed;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async persistCachedUser(storage, user) {
+        await storage.setItem(USER_CACHE_KEY, JSON.stringify(user));
+    }
+    normalizeUser(user) {
+        const normalized = { id: String(user.id) };
+        const attrs = this.normalizeAttributes(user.attributes);
+        if (attrs) {
+            normalized.attributes = attrs;
+            this.attributesByUserId.set(normalized.id, attrs);
+        }
+        return normalized;
+    }
+    normalizeAttributes(attributes) {
+        if (!attributes || typeof attributes !== 'object' || Array.isArray(attributes)) {
+            return undefined;
+        }
+        const blocked = Object.keys(attributes).filter((key) => BLOCKED_ATTRIBUTE_KEYS.has(key));
+        if (blocked.length > 0) {
+            throw new Error(`Blocked attribute key(s): ${blocked.join(', ')}. Remove reserved keys from user.attributes.`);
+        }
+        return { ...attributes };
+    }
+    mergeUser(user) {
+        const userId = String(user.id);
+        const incoming = this.normalizeAttributes(user.attributes);
+        const existing = this.attributesByUserId.get(userId);
+        const merged = { ...(existing ?? {}), ...(incoming ?? {}) };
+        const normalized = { id: userId };
+        if (Object.keys(merged).length > 0) {
+            normalized.attributes = merged;
+            this.attributesByUserId.set(userId, merged);
+        }
+        else {
+            this.attributesByUserId.delete(userId);
+        }
+        return normalized;
+    }
+    startPolling() {
+        if (this.pollTimer)
+            clearTimeout(this.pollTimer);
+        const interval = this.config?.pollingIntervalMs ?? DEFAULT_POLL_MS;
+        this.pollTimer = setTimeout(() => {
+            void this.refresh().finally(() => this.startPolling());
+        }, interval);
+        const timer = this.pollTimer;
+        timer.unref?.();
+    }
+    stopPolling() {
+        if (!this.pollTimer)
+            return;
+        clearTimeout(this.pollTimer);
+        this.pollTimer = undefined;
+    }
+    startStreamOrPolling() {
+        const streamEnabled = this.config?.streamEnabled ?? true;
+        const streamUrl = this.resolveStreamUrl();
+        if (!streamEnabled || !streamUrl) {
+            this.startPolling();
+            return;
+        }
+        this.startStreaming(streamUrl);
+    }
+    startStreaming(streamBaseUrl) {
+        this.stopStreaming();
+        const config = this.config;
+        const logger = config.logger ?? createDefaultLogger(false);
+        const url = new URL(streamBaseUrl);
+        url.searchParams.set('apiKey', config.apiKey);
+        let socket;
+        try {
+            socket = new WebSocket(url.toString());
+        }
+        catch {
+            logger.warn('Betsy stream open failed, using polling fallback');
+            this.startPolling();
+            this.scheduleStreamReconnect();
+            return;
+        }
+        this.streamSocket = socket;
+        this.startPolling();
+        socket.onopen = () => {
+            logger.info('Betsy stream connected');
+            this.stopPolling();
+        };
+        socket.onmessage = (event) => {
+            this.handleStreamMessage(event.data);
+        };
+        socket.onerror = () => {
+            logger.warn('Betsy stream error, polling fallback active');
+            this.startPolling();
+        };
+        socket.onclose = (event) => {
+            logger.warn('Betsy stream closed, reconnect scheduled', {
+                code: event.code,
+                reason: event.reason,
+            });
+            this.startPolling();
+            this.scheduleStreamReconnect();
+        };
+    }
+    stopStreaming() {
+        if (this.streamReconnectTimer) {
+            clearTimeout(this.streamReconnectTimer);
+            this.streamReconnectTimer = undefined;
+        }
+        if (!this.streamSocket)
+            return;
+        const socket = this.streamSocket;
+        this.streamSocket = undefined;
+        socket.onopen = null;
+        socket.onmessage = null;
+        socket.onerror = null;
+        socket.onclose = null;
+        if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING) {
+            socket.close();
+        }
+    }
+    scheduleStreamReconnect() {
+        if (this.streamReconnectTimer)
+            return;
+        const delayMs = Math.max(DEFAULT_STREAM_RECONNECT_MS, (this.config?.pollingIntervalMs ?? DEFAULT_POLL_MS) / 2);
+        this.streamReconnectTimer = setTimeout(() => {
+            this.streamReconnectTimer = undefined;
+            if (!this.config)
+                return;
+            const logger = this.config.logger ?? createDefaultLogger(false);
+            logger.debug('Betsy stream reconnecting');
+            this.startStreamOrPolling();
+        }, delayMs);
+        const timer = this.streamReconnectTimer;
+        timer.unref?.();
+    }
+    handleStreamMessage(raw) {
+        if (typeof raw !== 'string')
+            return;
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const messageType = typeof payload.type === 'string' ? payload.type : '';
+        if (messageType !== 'config_published')
+            return;
+        const incomingVersion = typeof payload.version === 'string' ? payload.version : '';
+        if (incomingVersion && this.latestConfigVersion && incomingVersion === this.latestConfigVersion) {
+            return;
+        }
+        void this.refresh();
+    }
+    resolveStreamUrl() {
+        const configured = this.config?.streamUrl?.trim();
+        if (configured)
+            return configured;
+        return DEFAULT_STREAM_URL;
+    }
+    startTelemetryFlush() {
+        if (this.telemetryTimer)
+            clearTimeout(this.telemetryTimer);
+        const interval = this.config?.telemetryFlushIntervalMs ?? DEFAULT_TELEMETRY_FLUSH_MS;
+        this.telemetryTimer = setTimeout(() => {
+            void this.flushTelemetry().finally(() => this.startTelemetryFlush());
+        }, interval);
+        const timer = this.telemetryTimer;
+        timer.unref?.();
+    }
+    async flushTelemetry() {
+        this.requireConfigured();
+        if ((this.config?.telemetryEnabled ?? true) === false)
+            return;
+        if (!this.telemetryQueue.length)
+            return;
+        const logger = this.config?.logger ?? createDefaultLogger(false);
+        const batchSize = this.config?.telemetryBatchSize ?? DEFAULT_TELEMETRY_BATCH_SIZE;
+        const events = this.telemetryQueue.slice(0, batchSize);
+        try {
+            logger.debug('Betsy telemetry flush started', {
+                count: events.length,
+                eventNames: events.map((event) => String(event.name ?? 'unknown')),
+            });
+            await this.getTransport().post('/v1/events/batch', {
+                apiKey: this.config.apiKey,
+                body: {
+                    events,
+                },
+            });
+            this.telemetryQueue.splice(0, events.length);
+            logger.debug('Betsy telemetry flush succeeded', {
+                flushedCount: events.length,
+                queueSize: this.telemetryQueue.length,
+            });
+        }
+        catch {
+            logger.warn('Betsy telemetry flush failed; keeping events queued', {
+                attemptedCount: events.length,
+                queueSize: this.telemetryQueue.length,
+            });
+            // Keep events queued for next flush attempt.
+        }
+    }
+    enqueueReadEvaluationEvents(flag) {
+        if ((this.config?.telemetryEnabled ?? true) === false)
+            return;
+        const now = new Date().toISOString();
+        const user = this.store.getState().user;
+        const payload = flag.payload ?? {};
+        const variationId = typeof payload === 'object' && typeof payload.variationId === 'string' ? payload.variationId : '';
+        const configVersion = typeof payload === 'object' && typeof payload.configVersion === 'string' ? payload.configVersion : '';
+        const readKey = `${user?.id ?? ''}:${flag.key}:${variationId}:${configVersion}`;
+        if (this.readEvaluationKeys.has(readKey))
+            return;
+        this.readEvaluationKeys.add(readKey);
+        const rawValue = flag.value === null || typeof flag.value === 'boolean' || typeof flag.value === 'number'
+            ? flag.value
+            : typeof flag.value === 'string'
+                ? flag.value.length > 120
+                    ? `${flag.value.slice(0, 117)}...`
+                    : flag.value
+                : '[complex]';
+        this.enqueueTelemetryEvent({
+            name: 'betsy.system.fetch_evaluation',
+            timestamp: now,
+            userId: user?.id ?? '',
+            anonymousId: this.anonymousDeviceId,
+            properties: {
+                sdkSource: this.sdkSource,
+                flagKey: flag.key,
+                variationId: variationId || undefined,
+                enabled: typeof payload === 'object' ? payload.enabled : undefined,
+                kind: typeof payload === 'object' ? payload.kind : undefined,
+                reason: typeof payload === 'object' ? payload.reason : undefined,
+                rolloutId: typeof payload === 'object' ? payload.rolloutId : undefined,
+                rolloutStepIndex: typeof payload === 'object' ? payload.rolloutStepIndex : undefined,
+                rolloutReason: typeof payload === 'object' ? payload.rolloutReason : undefined,
+                bucketBy: typeof payload === 'object' ? payload.bucketBy : undefined,
+                source: 'sdk-read',
+            },
+        }, 'read-evaluation');
+        this.enqueueTelemetryEvent({
+            name: 'betsy.system.fetch_evaluation_result',
+            timestamp: now,
+            userId: user?.id ?? '',
+            anonymousId: this.anonymousDeviceId,
+            properties: {
+                sdkSource: this.sdkSource,
+                flagKey: flag.key,
+                variationId: variationId || undefined,
+                value: rawValue,
+                source: 'sdk-read',
+            },
+        }, 'read-evaluation-result');
+    }
+    enqueueAssignmentEvents(flags) {
+        if ((this.config?.telemetryEnabled ?? true) === false)
+            return;
+        const now = new Date().toISOString();
+        const user = this.store.getState().user;
+        for (const flag of flags) {
+            const payload = (flag.payload ?? {});
+            const experimentId = typeof payload.experimentId === 'string' ? payload.experimentId : '';
+            const experimentArmId = typeof payload.experimentArmId === 'string' ? payload.experimentArmId : '';
+            const assignmentId = typeof payload.assignmentId === 'string' ? payload.assignmentId : '';
+            const configVersion = typeof payload.configVersion === 'string' ? payload.configVersion : '';
+            if (!experimentId || !experimentArmId || !assignmentId)
+                continue;
+            const key = `${assignmentId}:${configVersion || 'noversion'}`;
+            if (this.assignmentKeys.has(key))
+                continue;
+            this.assignmentKeys.add(key);
+            this.enqueueTelemetryEvent({
+                name: 'betsy.system.assignment',
+                timestamp: now,
+                userId: user?.id ?? '',
+                anonymousId: this.anonymousDeviceId,
+                properties: {
+                    sdkSource: this.sdkSource,
+                    flagKey: flag.key,
+                    variationId: typeof payload.variationId === 'string' ? payload.variationId : undefined,
+                    experimentId,
+                    experimentArmId,
+                    assignmentId,
+                    configVersion: configVersion || undefined,
+                    source: 'sdk',
+                },
+            }, 'assignment');
+        }
+    }
+    async enqueueExposure(flag, options) {
+        const payload = (flag.payload ?? {});
+        const variationId = typeof payload.variationId === 'string' ? payload.variationId : '';
+        const configVersion = typeof payload.configVersion === 'string' ? payload.configVersion : '';
+        const experimentId = typeof payload.experimentId === 'string' ? payload.experimentId : '';
+        const experimentArmId = typeof payload.experimentArmId === 'string' ? payload.experimentArmId : '';
+        const assignmentId = typeof payload.assignmentId === 'string' ? payload.assignmentId : '';
+        const includeExperimentProperties = Boolean(experimentId && experimentArmId && assignmentId);
+        const user = this.store.getState().user;
+        const exposureKey = `${user?.id ?? ''}:${flag.key}:${variationId}:${configVersion}`;
+        if (this.exposureKeys.has(exposureKey))
+            return;
+        this.exposureKeys.add(exposureKey);
+        await this.track('betsy.system.exposure', {
+            sdkSource: this.sdkSource,
+            flagKey: flag.key,
+            variationId: variationId || undefined,
+            experimentId: includeExperimentProperties ? experimentId : undefined,
+            experimentArmId: includeExperimentProperties ? experimentArmId : undefined,
+            assignmentId: includeExperimentProperties ? assignmentId : undefined,
+            configVersion: configVersion || undefined,
+            reason: typeof payload.reason === 'string' ? payload.reason : undefined,
+            rolloutId: typeof payload.rolloutId === 'string' ? payload.rolloutId : undefined,
+            rolloutStepIndex: typeof payload.rolloutStepIndex === 'number' ? payload.rolloutStepIndex : undefined,
+            rolloutReason: typeof payload.rolloutReason === 'string' ? payload.rolloutReason : undefined,
+            source: 'sdk',
+            ...(options?.properties ?? {}),
+        }, options?.immediate !== undefined ? { immediate: options.immediate } : undefined);
+    }
+    clearError() {
+        const state = this.store.getState();
+        if (state.error === undefined)
+            return;
+        const { error: _error, ...rest } = state;
+        this.store.setState(rest);
+    }
+    extractOfflineFallbackFlags(flags) {
+        const out = [];
+        for (const flag of flags) {
+            const payload = flag.payload;
+            const fallbackValue = payload && typeof payload === 'object'
+                ? payload.offlineFallbackValue
+                : undefined;
+            if (fallbackValue === undefined)
+                continue;
+            out.push({
+                key: flag.key,
+                value: fallbackValue,
+                payload: {
+                    ...(payload ?? {}),
+                    source: 'offline-fallback',
+                },
+            });
+        }
+        return indexFlags(out);
+    }
+}
+//# sourceMappingURL=client.js.map