react-native-featureflags 0.3.0 → 1.0.0

package/dist/client.js

@@ -1,859 +1,2 @@
-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 { createAsyncStorageAdapter } from './storage.js';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-const ANON_ID_KEY = 'truflag:rn:anon-id';
-const USER_CACHE_KEY = 'truflag:rn:user';
-const SNAPSHOT_KEY = 'truflag:rn:snapshot';
-const ASSIGNMENT_KEYS_CACHE_KEY = 'truflag:rn:assignment-keys';
-const MAX_PERSISTED_ASSIGNMENT_KEYS = 1000;
-const RELAY_BASE_URL = 'https://sdk.truflag.com/';
-const DEFAULT_STREAM_URL = 'wss://stream.sdk.truflag.com';
-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 = [];
-    exposureIdentityByFlag = new Map();
-    assignmentIdentityByFlag = new Map();
-    readEvaluationIdentityByFlag = new Map();
-    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;
-        const resolvedStorage = options.storage ?? this.resolveDefaultStorageAdapter();
-        this.config = { ...options, storage: resolvedStorage };
-        const logger = options.logger ?? createDefaultLogger(true);
-        logger.info('Configuring Truflag RN SDK', { apiKey: maskApiKey(options.apiKey) });
-        const storage = resolvedStorage;
-        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;
-        await this.loadPersistedAssignmentKeys(storage);
-        this.clearError();
-        await this.refresh();
-        this.startStreamOrPolling();
-        this.startTelemetryFlush();
-    }
-    async login(user) {
-        this.requireConfigured();
-        const nextUser = this.mergeUser(user);
-        this.store.patch({ user: nextUser });
-        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 });
-        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 });
-        await this.persistCachedUser(storage, user);
-        await this.refresh();
-    }
-    async refresh() {
-        this.requireConfigured();
-        const config = this.config;
-        const logger = config.logger ?? createDefaultLogger(true);
-        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('Truflag 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.getFlagOrThrow(flagKey);
-        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) {
-        const flags = this.store.getState().flags;
-        const flag = this.getFlagOrThrow(key);
-        this.enqueueReadEvaluationEvents(flag);
-        void this.enqueueExposure(flag);
-        return evaluateBooleanFlag(flags, key, defaultValue);
-    }
-    getFeatureFlagValue(key, defaultValue) {
-        const flags = this.store.getState().flags;
-        const flag = this.getFlagOrThrow(key);
-        this.enqueueReadEvaluationEvents(flag);
-        void this.enqueueExposure(flag);
-        return evaluateFlagValue(flags, key, defaultValue);
-    }
-    getFeatureFlagPayload(key) {
-        const flags = this.store.getState().flags;
-        this.getFlagOrThrow(key);
-        return getFlagPayload(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() {
-        const storage = this.config?.storage;
-        if (!storage) {
-            throw new Error('React Native SDK requires AsyncStorage. Install @react-native-async-storage/async-storage or pass storage explicitly.');
-        }
-        return storage;
-    }
-    resolveDefaultStorageAdapter() {
-        const candidate = AsyncStorage;
-        if (!candidate ||
-            typeof candidate.getItem !== 'function' ||
-            typeof candidate.setItem !== 'function' ||
-            typeof candidate.removeItem !== 'function') {
-            throw new Error('React Native SDK requires @react-native-async-storage/async-storage. Install it or pass storage explicitly.');
-        }
-        return createAsyncStorageAdapter(candidate);
-    }
-    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;
-        const baseUrl = (config.baseUrl?.trim() || RELAY_BASE_URL).replace(/\/+$/, '/');
-        return new FetchTransport(baseUrl, config.fetchFn);
-    }
-    getFlagOrThrow(key) {
-        const flag = this.store.getState().flags[key];
-        if (flag)
-            return flag;
-        const logger = this.config?.logger ?? createDefaultLogger(true);
-        logger.error('Truflag missing flag access', { flagKey: key });
-        throw new Error(`Flag "${key}" does not exist in SDK state.`);
-    }
-    enqueueTelemetryEvent(event, reason) {
-        this.telemetryQueue.push(event);
-        const logger = this.config?.logger ?? createDefaultLogger(true);
-        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('Truflag 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,
-            baseUrl: options.baseUrl ?? '',
-            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));
-    }
-    async loadPersistedAssignmentKeys(storage) {
-        this.assignmentIdentityByFlag.clear();
-        const raw = await storage.getItem(ASSIGNMENT_KEYS_CACHE_KEY);
-        if (!raw)
-            return;
-        try {
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed)) {
-                const keys = parsed.filter((entry) => typeof entry === 'string' && entry.length > 0);
-                const tail = keys.slice(-MAX_PERSISTED_ASSIGNMENT_KEYS);
-                for (const key of tail) {
-                    this.assignmentIdentityByFlag.set(`legacy:${this.assignmentIdentityByFlag.size}`, key);
-                }
-                return;
-            }
-            if (!parsed || typeof parsed !== 'object')
-                return;
-            const entries = Object.entries(parsed)
-                .filter((entry) => typeof entry[0] === 'string' && typeof entry[1] === 'string')
-                .slice(-MAX_PERSISTED_ASSIGNMENT_KEYS);
-            for (const [flagKey, identity] of entries) {
-                if (!flagKey || !identity)
-                    continue;
-                this.assignmentIdentityByFlag.set(flagKey, identity);
-            }
-        }
-        catch {
-            // Ignore malformed cache and proceed with empty set.
-        }
-    }
-    async persistAssignmentKeys() {
-        const storage = this.config?.storage;
-        if (!storage)
-            return;
-        const entries = Array.from(this.assignmentIdentityByFlag.entries()).slice(-MAX_PERSISTED_ASSIGNMENT_KEYS);
-        this.assignmentIdentityByFlag.clear();
-        for (const [flagKey, identity] of entries) {
-            this.assignmentIdentityByFlag.set(flagKey, identity);
-        }
-        await storage.setItem(ASSIGNMENT_KEYS_CACHE_KEY, JSON.stringify(Object.fromEntries(entries)));
-    }
-    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(true);
-        const url = new URL(streamBaseUrl);
-        url.searchParams.set('apiKey', config.apiKey);
-        let socket;
-        try {
-            socket = new WebSocket(url.toString());
-        }
-        catch {
-            logger.warn('Truflag stream open failed, using polling fallback');
-            this.startPolling();
-            this.scheduleStreamReconnect();
-            return;
-        }
-        this.streamSocket = socket;
-        this.startPolling();
-        socket.onopen = () => {
-            logger.info('Truflag stream connected');
-            this.stopPolling();
-        };
-        socket.onmessage = (event) => {
-            this.handleStreamMessage(event.data);
-        };
-        socket.onerror = () => {
-            logger.warn('Truflag stream error, polling fallback active');
-            this.startPolling();
-        };
-        socket.onclose = (event) => {
-            logger.warn('Truflag 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(true);
-            logger.debug('Truflag 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(true);
-        const batchSize = this.config?.telemetryBatchSize ?? DEFAULT_TELEMETRY_BATCH_SIZE;
-        const events = this.telemetryQueue.slice(0, batchSize);
-        try {
-            logger.debug('Truflag 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('Truflag telemetry flush succeeded', {
-                flushedCount: events.length,
-                queueSize: this.telemetryQueue.length,
-            });
-        }
-        catch {
-            logger.warn('Truflag 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 = this.getFlagPayloadRecord(flag);
-        const variationId = typeof payload === 'object' && typeof payload.variationId === 'string' ? payload.variationId : '';
-        if (!this.shouldEmitFlagIdentity(this.readEvaluationIdentityByFlag, flag.key, this.buildReadIdentity(flag))) {
-            return;
-        }
-        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: 'truflag.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: 'truflag.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;
-        let addedIdentity = false;
-        for (const flag of flags) {
-            const payload = this.getFlagPayloadRecord(flag);
-            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;
-            if (!this.shouldEmitFlagIdentity(this.assignmentIdentityByFlag, flag.key, this.buildAssignmentIdentity(flag))) {
-                continue;
-            }
-            addedIdentity = true;
-            this.enqueueTelemetryEvent({
-                name: 'truflag.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');
-        }
-        if (addedIdentity)
-            void this.persistAssignmentKeys();
-    }
-    async enqueueExposure(flag, options) {
-        const payload = this.getFlagPayloadRecord(flag);
-        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);
-        if (!this.shouldEmitFlagIdentity(this.exposureIdentityByFlag, flag.key, this.buildExposureIdentity(flag))) {
-            return;
-        }
-        await this.track('truflag.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);
-    }
-    getFlagPayloadRecord(flag) {
-        const payload = flag.payload;
-        return payload && typeof payload === 'object' && !Array.isArray(payload)
-            ? payload
-            : {};
-    }
-    shouldEmitFlagIdentity(cache, cacheKey, identity) {
-        if (cache.get(cacheKey) === identity)
-            return false;
-        cache.set(cacheKey, identity);
-        return true;
-    }
-    buildReadIdentity(flag) {
-        return this.buildFlagTelemetryIdentity(flag, 'read');
-    }
-    buildExposureIdentity(flag) {
-        return this.buildFlagTelemetryIdentity(flag, 'exposure');
-    }
-    buildAssignmentIdentity(flag) {
-        const payload = this.getFlagPayloadRecord(flag);
-        return this.joinTelemetryIdentityParts([
-            'assignment',
-            this.getTelemetryIdentitySegment('user', this.store.getState().user?.id),
-            this.getTelemetryIdentitySegment('anon', this.anonymousDeviceId),
-            this.getTelemetryIdentitySegment('env', this.readStringProperty(payload, 'environmentId')),
-            this.getTelemetryIdentitySegment('flag', flag.key),
-            this.getTelemetryIdentitySegment('config', this.readStringProperty(payload, 'configVersion')),
-            this.getTelemetryIdentitySegment('assignment', this.readStringProperty(payload, 'assignmentId')),
-            this.getTelemetryIdentitySegment('experiment', this.readStringProperty(payload, 'experimentId')),
-            this.getTelemetryIdentitySegment('arm', this.readStringProperty(payload, 'experimentArmId')),
-            this.getTelemetryIdentitySegment('variation', this.readStringProperty(payload, 'variationId')),
-        ]);
-    }
-    buildFlagTelemetryIdentity(flag, eventType) {
-        const payload = this.getFlagPayloadRecord(flag);
-        return this.joinTelemetryIdentityParts([
-            eventType,
-            this.getTelemetryIdentitySegment('user', this.store.getState().user?.id),
-            this.getTelemetryIdentitySegment('anon', this.anonymousDeviceId),
-            this.getTelemetryIdentitySegment('env', this.readStringProperty(payload, 'environmentId')),
-            this.getTelemetryIdentitySegment('flag', flag.key),
-            this.getTelemetryIdentitySegment('config', this.readStringProperty(payload, 'configVersion')),
-            this.getTelemetryIdentitySegment('assignment', this.readStringProperty(payload, 'assignmentId')),
-            this.getTelemetryIdentitySegment('variation', this.readStringProperty(payload, 'variationId')),
-            this.getTelemetryIdentitySegment('value', this.fingerprintTelemetryValue(flag.value)),
-        ]);
-    }
-    readStringProperty(payload, key) {
-        const value = payload[key];
-        return typeof value === 'string' ? value : '';
-    }
-    getTelemetryIdentitySegment(label, value) {
-        return `${label}=${String(value ?? '')}`;
-    }
-    joinTelemetryIdentityParts(parts) {
-        return parts.join('|');
-    }
-    fingerprintTelemetryValue(value) {
-        const serialized = this.serializeTelemetryValue(value);
-        let hash = 2166136261;
-        for (let index = 0; index < serialized.length; index += 1) {
-            hash ^= serialized.charCodeAt(index);
-            hash = Math.imul(hash, 16777619);
-        }
-        return `${serialized.length}:${(hash >>> 0).toString(16)}`;
-    }
-    serializeTelemetryValue(value) {
-        if (value === null)
-            return 'null';
-        if (value === undefined)
-            return 'undefined';
-        if (typeof value === 'string')
-            return JSON.stringify(value);
-        if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
-            return String(value);
-        }
-        if (Array.isArray(value)) {
-            return `[${value.map((entry) => this.serializeTelemetryValue(entry)).join(',')}]`;
-        }
-        if (typeof value === 'object') {
-            const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
-            return `{${entries
-                .map(([key, entryValue]) => `${JSON.stringify(key)}:${this.serializeTelemetryValue(entryValue)}`)
-                .join(',')}}`;
-        }
-        return String(value);
-    }
-    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);
-    }
-}
+export { ReactNativeFlagsClient } from '@truflag/sdk-platform-react-native';
 //# sourceMappingURL=client.js.map