@configdirector/react-native-sdk 1.10.1 → 1.11.0

package/dist/configdirector-react-native-testing.d.mts

@@ -1,4 +1,4 @@
-import { c as NativeJsonValue, d as ConfigDirectorContext, i as ConfigDirectorClient, l as NativeValue, p as ConfigDirectorLogger, u as NativeValues } from "./types-DmbDeZqL.mjs";
+import { S as TrackedEventDetails, b as TrackedEvent, c as NativeJsonValue, d as ConfigDirectorContext, i as ConfigDirectorClient, l as NativeValue, p as ConfigDirectorLogger, u as NativeValues, x as TrackedEventDetailValue } from "./types-BCVhD8m2.mjs";
 
 //#region ../shared/src/errors.d.ts
 declare class ConfigDirectorConnectionError extends Error {
@@ -28,7 +28,9 @@ type TestClientOptions = {
    */
   timeout?: number;
   /**
-   * The logger the SDK client uses. Defaults to the SDK's console logger at `warn` level.
+   * The logger the SDK client uses. Defaults to the SDK's console logger at `warn` level. Since the
+   * test client sends no telemetry, every tracked event that is not recorded as it was tracked logs
+   * a warning, rather than each cause once per telemetry batch.
    */
   logger?: ConfigDirectorLogger;
 };
@@ -97,6 +99,13 @@ interface TestClient {
    * the client connects without it. Resumes are not recorded.
    */
   readonly contextUpdates: ConfigDirectorContext[];
+  /**
+   * Every event the code under test tracked through the client, in call order, with the context
+   * the client had at that moment, as the SDK would report it: an event whose name does not have
+   * 1 to 150 characters is not recorded, and a value or details the SDK would leave out are missing
+   * from the record. The limit of 1,000 events per telemetry batch does not apply.
+   */
+  readonly trackedEvents: TrackedEvent[];
 }
 //#endregion
 //#region ../js-client-core/src/testing/installTestClient.d.ts
@@ -146,4 +155,4 @@ declare const installTestClient: (testClient: TestClient) => (() => void);
  */
 declare const createTestClient: (options?: TestClientOptions) => TestClient;
 //#endregion
-export { ConfigDirectorConnectionError, ConfigDirectorValidationError, type TestClient, type TestClientOptions, type NativeJsonValue as TestJsonValue, type NativeValue as TestValue, type NativeValues as TestValues, createTestClient, installTestClient };
+export { ConfigDirectorConnectionError, ConfigDirectorValidationError, type TestClient, type TestClientOptions, type NativeJsonValue as TestJsonValue, type NativeValue as TestValue, type NativeValues as TestValues, type TrackedEvent, type TrackedEventDetailValue, type TrackedEventDetails, createTestClient, installTestClient };

package/dist/configdirector-react-native-testing.mjs

@@ -1,4 +1,27 @@
-import { c as createDefaultLogger, d as ConfigDirectorConnectionError, f as ConfigDirectorValidationError, l as nativeValueConfigState, m as _defineProperty, p as Emitter, r as DefaultConfigDirectorClient, s as discardingTelemetryClient, t as INSTALLED_TEST_CLIENT_SLOT } from "./installedTestClient-CM98r0qu.mjs";
+import { _ as Emitter, c as trackedEventWarningMessages, d as discardingTelemetryClient, f as createDefaultLogger, g as ConfigDirectorValidationError, h as ConfigDirectorConnectionError, p as nativeValueConfigState, r as DefaultConfigDirectorClient, t as INSTALLED_TEST_CLIENT_SLOT, v as _defineProperty } from "./installedTestClient-BopKe_F5.mjs";
+//#region ../shared/src/telemetry/RecordedTrackedEvents.ts
+const recordedEventOf = (entry, context) => ({
+	name: entry.name,
+	...context === void 0 ? {} : { context },
+	...entry.value === void 0 ? {} : { value: entry.value },
+	...entry.details === void 0 ? {} : { details: entry.details }
+});
+var RecordedTrackedEvents = class {
+	constructor(logger) {
+		this.logger = logger;
+		_defineProperty(this, "events", []);
+	}
+	record(admission, context) {
+		admission.warnings.forEach((warning) => this.logger.warn(trackedEventWarningMessages[warning]));
+		switch (admission.outcome) {
+			case "dropped": return;
+			case "admitted":
+				this.events.push(recordedEventOf(admission.entry, context));
+				return;
+		}
+	}
+};
+//#endregion
 //#region ../js-client-core/src/testing/InMemoryConnection.ts
 const TEST_ENVIRONMENT = {
 	environmentId: "test-environment",
@@ -195,9 +218,10 @@ var InMemoryConnection = class {
 //#region ../js-client-core/src/testing/TestClient.ts
 const TEST_CLIENT_SDK_KEY = "test-client";
 var InMemoryTestClient = class {
-	constructor(client, connection) {
+	constructor(client, connection, trackedEvents) {
 		this.client = client;
 		this.connection = connection;
+		this.trackedEvents = trackedEvents;
 	}
 	setValue(key, value) {
 		this.connection.setValue(key, value);
@@ -234,10 +258,14 @@ const createTestClient$1 = (sdkOptions, options) => {
 	var _options$logger, _options$values;
 	const logger = (_options$logger = options === null || options === void 0 ? void 0 : options.logger) !== null && _options$logger !== void 0 ? _options$logger : createDefaultLogger();
 	const connection = new InMemoryConnection(logger, (_options$values = options === null || options === void 0 ? void 0 : options.values) !== null && _options$values !== void 0 ? _options$values : {});
-	return new InMemoryTestClient(new DefaultConfigDirectorClient(() => discardingTelemetryClient, TEST_CLIENT_SDK_KEY, sdkOptions, {
+	const recordedTrackedEvents = new RecordedTrackedEvents(logger);
+	return new InMemoryTestClient(new DefaultConfigDirectorClient(() => ({
+		...discardingTelemetryClient,
+		trackedEvent: (admission, context) => recordedTrackedEvents.record(admission, context)
+	}), TEST_CLIENT_SDK_KEY, sdkOptions, {
 		logger,
 		connection: { timeout: options === null || options === void 0 ? void 0 : options.timeout }
-	}, { transport: connection }), connection);
+	}, { transport: connection }), connection, recordedTrackedEvents.events);
 };
 //#endregion
 //#region ../js-client-core/src/testing/installTestClient.ts
@@ -295,7 +323,7 @@ const installTestClient = (testClient) => {
 const createTestClient = (options) => {
 	return createTestClient$1({
 		sdkName: "react-native-sdk",
-		sdkVersion: "1.10.1"
+		sdkVersion: "1.11.0"
 	}, options);
 };
 //#endregion

package/dist/configdirector-react-native.d.mts

@@ -1,4 +1,4 @@
-import { _ as ConnectionMode, a as ConfigDirectorClientOptions, d as ConfigDirectorContext, f as ConfigDirectorLogMessageDecorator, g as ConfigValueType, h as ConfigEvaluation, i as ConfigDirectorClient, m as ConfigDirectorLoggingLevel, n as CachingProvider, o as OfflineValue, p as ConfigDirectorLogger, r as ClientHooks, s as OfflineValues, t as CachingOptions, v as EvaluationReason } from "./types-DmbDeZqL.mjs";
+import { C as Variation, S as TrackedEventDetails, _ as ConnectionMode, a as ConfigDirectorClientOptions, d as ConfigDirectorContext, f as ConfigDirectorLogMessageDecorator, g as ConfigValueType, h as ConfigEvaluation, i as ConfigDirectorClient, m as ConfigDirectorLoggingLevel, n as CachingProvider, o as OfflineValue, p as ConfigDirectorLogger, r as ClientHooks, s as OfflineValues, t as CachingOptions, v as EvaluationReason, x as TrackedEventDetailValue, y as TrackOptions } from "./types-BCVhD8m2.mjs";
 import { Component, PropsWithChildren } from "react";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 
@@ -151,4 +151,4 @@ declare class ConfigDirectorReactContextError extends Error {
 //#region src/logger.d.ts
 declare const createConsoleLogger: (level?: ConfigDirectorLoggingLevel) => DefaultConsoleLogger;
 //#endregion
-export { type CachingOptions, type CachingProvider, type ClientStatus, type ConfigDirectorClient, type ConfigDirectorClientOptions, type ConfigDirectorContext, type ConfigDirectorLogger, type ConfigDirectorLoggingLevel, ConfigDirectorProvider, type ConfigDirectorProviderClientProps, type ConfigDirectorProviderOptions, type ConfigDirectorProviderProps, ConfigDirectorReactContextError, type ConfigEvaluation, type ConnectionMode, type EvaluationReason, type NetInfoSubscribe, type OfflineValue, type OfflineValues, createClient, createConsoleLogger, useClient, useConfigValue, useContext };
+export { type CachingOptions, type CachingProvider, type ClientStatus, type ConfigDirectorClient, type ConfigDirectorClientOptions, type ConfigDirectorContext, type ConfigDirectorLogger, type ConfigDirectorLoggingLevel, ConfigDirectorProvider, type ConfigDirectorProviderClientProps, type ConfigDirectorProviderOptions, type ConfigDirectorProviderProps, ConfigDirectorReactContextError, type ConfigEvaluation, type ConnectionMode, type EvaluationReason, type NetInfoSubscribe, type OfflineValue, type OfflineValues, type TrackOptions, type TrackedEventDetailValue, type TrackedEventDetails, type Variation, createClient, createConsoleLogger, useClient, useConfigValue, useContext };

package/dist/configdirector-react-native.mjs

@@ -1,4 +1,4 @@
-import { a as DEFAULT_CACHING_SIZE_LIMIT_BYTES, c as createDefaultLogger, i as CACHED_VALUES_STORAGE_KEY_PREFIX, m as _defineProperty, n as readInstalledTestClient, o as fetchWithTimeout, r as DefaultConfigDirectorClient, u as isFetchErrorFatal } from "./installedTestClient-CM98r0qu.mjs";
+import { a as DEFAULT_CACHING_SIZE_LIMIT_BYTES, f as createDefaultLogger, i as CACHED_VALUES_STORAGE_KEY_PREFIX, l as utf8ByteLength, m as isFetchErrorFatal, n as readInstalledTestClient, r as DefaultConfigDirectorClient, s as logBatchWarnings, u as fetchWithTimeout, v as _defineProperty } from "./installedTestClient-BopKe_F5.mjs";
 import React, { Component, useContext as useContext$1 } from "react";
 import { AppState, NativeModules } from "react-native";
 import { sha256 } from "@noble/hashes/sha2.js";
@@ -58,6 +58,7 @@ const isDroppedEventsEmpty = (droppedEvents) => {
 };
 //#endregion
 //#region ../js-client-core/src/telemetry/ClientEventReporter.ts
+const LARGEST_BODY_SENT_WITH_KEEPALIVE_BYTES = 64 * 1024 / 2;
 var ClientEventReporter = class {
 	constructor(options) {
 		_defineProperty(this, "sdkKey", void 0);
@@ -107,10 +108,11 @@ var ClientEventReporter = class {
 	}
 	async sendReport(eventReport) {
 		try {
+			const body = JSON.stringify(eventReport);
 			const response = await fetchWithTimeout(5e3, this.url, {
 				method: "POST",
-				body: JSON.stringify(eventReport),
-				keepalive: true
+				body,
+				keepalive: utf8ByteLength(body) <= LARGEST_BODY_SENT_WITH_KEEPALIVE_BYTES
 			}, this.logger);
 			const isFatalError = this.isStatusFatal(response.status);
 			if (isFatalError) this.logger.warn(`[EventReporter] Received a fatal status response (${response.status}) from the telemetry endpoint. No more telemetry data will be sent.`);
@@ -209,6 +211,43 @@ var EventQueue = class {
 	}
 };
 //#endregion
+//#region ../shared/src/telemetry/TrackedEventQueue.ts
+var TrackedEventQueue = class {
+	constructor() {
+		_defineProperty(this, "entries", []);
+		_defineProperty(this, "warningsRaisedThisBatch", /* @__PURE__ */ new Set());
+	}
+	add(admission) {
+		return this.warningsOfKeeping(admission).filter((warning) => this.isFirstThisBatch(warning));
+	}
+	absorb(entries) {
+		this.entries.push(...entries);
+	}
+	takeBatch() {
+		const batch = this.entries;
+		this.clear();
+		return batch;
+	}
+	clear() {
+		this.entries = [];
+		this.warningsRaisedThisBatch.clear();
+	}
+	warningsOfKeeping(admission) {
+		switch (admission.outcome) {
+			case "dropped": return admission.warnings;
+			case "admitted":
+				if (this.entries.length >= 1e3) return ["batch-already-full"];
+				this.entries.push(admission.entry);
+				return admission.warnings;
+		}
+	}
+	isFirstThisBatch(warning) {
+		if (this.warningsRaisedThisBatch.has(warning)) return false;
+		this.warningsRaisedThisBatch.add(warning);
+		return true;
+	}
+};
+//#endregion
 //#region ../shared/src/telemetry/TelemetryEventCollector.ts
 var TelemetryEventCollector = class {
 	constructor(options) {
@@ -216,6 +255,7 @@ var TelemetryEventCollector = class {
 		_defineProperty(this, "logger", void 0);
 		_defineProperty(this, "evaluationEventQueue", void 0);
 		_defineProperty(this, "aggregator", new EventAggregator());
+		_defineProperty(this, "trackedEventQueue", new TrackedEventQueue());
 		_defineProperty(this, "flushIntervalDelay", void 0);
 		_defineProperty(this, "flushTimeout", void 0);
 		_defineProperty(this, "collectEvents", true);
@@ -231,6 +271,10 @@ var TelemetryEventCollector = class {
 		this.started = true;
 		this.flushTimeout = setTimeout(() => this.flushAndScheduleNext(), this.initialFlushIntervalDelay);
 	}
+	trackedEvent(admission) {
+		if (!this.collectEvents) return;
+		logBatchWarnings(this.logger, this.trackedEventQueue.add(admission));
+	}
 	async flushAndScheduleNext() {
 		if (!this.collectEvents) return;
 		let response;
@@ -264,6 +308,7 @@ var TelemetryEventCollector = class {
 			this.logger.warn("[TelemetryEventCollector] Error flushing telemetry events during close: ", error);
 		}
 		this.evaluationEventQueue.clear();
+		this.trackedEventQueue.clear();
 	}
 	dispose() {
 		this.close();
@@ -375,6 +420,9 @@ var ClientTelemetryEventCollector = class extends TelemetryEventCollector {
 	absorbInvalidContextSubmissions(entries) {
 		this.invalidContextSubmissions.absorb(entries);
 	}
+	absorbTrackedEventEntries(entries) {
+		this.trackedEventQueue.absorb(entries);
+	}
 	async forceFlush() {
 		this.cancelScheduledFlush();
 		await this.flushAndScheduleNext();
@@ -388,7 +436,7 @@ var ClientTelemetryEventCollector = class extends TelemetryEventCollector {
 		const evaluationSnapshot = await this.evaluationEventSnapshotPreprocessor.process(this.evaluationEventQueue.takeSnapshot());
 		return await ((_this$reporter = this.reporter) === null || _this$reporter === void 0 ? void 0 : _this$reporter.report({
 			context: this._context,
-			discreteEvents: {},
+			discreteEvents: { trackedEvents: this.trackedEventQueue.takeBatch() },
 			aggregatedEvents: {
 				evaluatedConfig: this.aggregator.aggregate(evaluationSnapshot),
 				invalidContext: this.invalidContextSubmissions.takeSnapshot()
@@ -734,6 +782,9 @@ var ReactNativeTelemetryClient = class {
 	recordInvalidContext(kindSample) {
 		this.collector.recordInvalidContext(kindSample);
 	}
+	trackedEvent(admission) {
+		this.collector.trackedEvent(admission);
+	}
 	async close() {
 		await this.collector.close();
 	}
@@ -777,7 +828,7 @@ const createReactNativeClient = (clientSdkKey, clientOptions) => {
 	var _clientOptions$logger;
 	const sdkIdentity = {
 		sdkName: "react-native-sdk",
-		sdkVersion: "1.10.1"
+		sdkVersion: "1.11.0"
 	};
 	const logger = (_clientOptions$logger = clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.logger) !== null && _clientOptions$logger !== void 0 ? _clientOptions$logger : createConsoleLogger("warn");
 	const metadata = resolveMetadata(clientOptions === null || clientOptions === void 0 ? void 0 : clientOptions.metadata, logger);

package/dist/{installedTestClient-CM98r0qu.mjs → installedTestClient-BopKe_F5.mjs}

@@ -724,6 +724,27 @@ const offlineSourceOf = (connection) => {
 };
 //#endregion
 //#region ../shared/src/value-parser.ts
+const NO_VARIATION_OR_ROLLOUT_SHARE = {
+	variation: void 0,
+	ruleId: void 0,
+	shareId: void 0
+};
+const variationOf = (configState) => {
+	const variation = configState.variation;
+	if (variation == null) return;
+	return variation.name ? {
+		id: variation.id,
+		name: variation.name
+	} : { id: variation.id };
+};
+const variationAndRolloutShareOf = (configState) => {
+	var _configState$ruleId, _configState$shareId;
+	return {
+		variation: variationOf(configState),
+		ruleId: (_configState$ruleId = configState.ruleId) !== null && _configState$ruleId !== void 0 ? _configState$ruleId : void 0,
+		shareId: (_configState$shareId = configState.shareId) !== null && _configState$shareId !== void 0 ? _configState$shareId : void 0
+	};
+};
 const getRequestedType = (defaultValue) => {
 	const baseType = typeof defaultValue;
 	if (baseType === "object") try {
@@ -749,6 +770,13 @@ const configTypesNotReadableAsString = new Set([
 	"float"
 ]);
 const parseConfigValue = (configState, defaultValue) => {
+	const valueAndReason = parseValueAndReason(configState, defaultValue);
+	return {
+		...valueAndReason,
+		...valueAndReason.usedDefault ? NO_VARIATION_OR_ROLLOUT_SHARE : variationAndRolloutShareOf(configState)
+	};
+};
+const parseValueAndReason = (configState, defaultValue) => {
 	const value = configState.value;
 	const requestedType = getRequestedType(defaultValue);
 	if (value == null || value === "") return {
@@ -954,6 +982,7 @@ const discardingTelemetryClient = {
 	updateContext: async () => {},
 	evaluatedConfig: () => {},
 	recordInvalidContext: () => {},
+	trackedEvent: () => {},
 	close: async () => {}
 };
 //#endregion
@@ -1338,6 +1367,93 @@ const utf8ByteLength = (text) => {
 	return bytes;
 };
 //#endregion
+//#region ../shared/src/telemetry/reported-context.ts
+const USER_CONTEXT_KIND = "user";
+const reportedContextOf = (context) => {
+	var _context$kind;
+	const contextIdentifier = (context === null || context === void 0 ? void 0 : context.anonymous) ? void 0 : context === null || context === void 0 ? void 0 : context.id;
+	if (contextIdentifier === void 0) return {};
+	return {
+		contextKind: (_context$kind = context === null || context === void 0 ? void 0 : context.kind) !== null && _context$kind !== void 0 ? _context$kind : USER_CONTEXT_KIND,
+		contextIdentifier
+	};
+};
+//#endregion
+//#region ../shared/src/telemetry/tracked-events.ts
+const TRACKED_EVENTS_PER_BATCH = 1e3;
+const NAME_MAXIMUM_CHARACTERS = 150;
+const NAME_MAXIMUM_UTF16_UNITS = NAME_MAXIMUM_CHARACTERS * 2;
+const DETAILS_MAXIMUM_TOP_LEVEL_KEYS = 20;
+const DETAILS_MAXIMUM_JSON_BYTES = 1024;
+const trackedEventWarningMessages = {
+	"name-outside-the-character-limit": `[ConfigDirectorClient] A tracked event was not reported because its name does not have 1 to ${NAME_MAXIMUM_CHARACTERS} characters.`,
+	"value-not-a-finite-number": "[ConfigDirectorClient] A tracked event was reported without its value because the value is not a finite number.",
+	"details-not-reportable": `[ConfigDirectorClient] A tracked event was reported without its details because they are not an object, have more than ${DETAILS_MAXIMUM_TOP_LEVEL_KEYS} top-level keys, are larger than ${DETAILS_MAXIMUM_JSON_BYTES} bytes as JSON, or cannot be written as JSON.`,
+	"batch-already-full": `[ConfigDirectorClient] A tracked event was not reported because ${TRACKED_EVENTS_PER_BATCH} tracked events are already waiting for the next telemetry batch.`
+};
+const logBatchWarnings = (logger, warnings) => {
+	for (const warning of warnings) logger.warn(`${trackedEventWarningMessages[warning]} Further tracked events like it are not logged until the next telemetry batch is sent.`);
+};
+const isGiven = (option) => option !== void 0 && option !== null;
+const isNonArrayObject = (candidate) => typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+const isWithinTheCharacterLimit = (name) => typeof name === "string" && name.length >= 1 && name.length <= NAME_MAXIMUM_UTF16_UNITS && Array.from(name).length <= NAME_MAXIMUM_CHARACTERS;
+const reportableValueOf = (value) => {
+	if (!isGiven(value)) return { status: "not-given" };
+	if (typeof value === "number" && Number.isFinite(value)) return {
+		status: "reportable",
+		fields: { value }
+	};
+	return {
+		status: "left-out",
+		warning: "value-not-a-finite-number"
+	};
+};
+const jsonCopyWithinTheLimits = (details) => {
+	if (!isNonArrayObject(details)) return;
+	try {
+		const json = JSON.stringify(details);
+		if (typeof json !== "string" || utf8ByteLength(json) > DETAILS_MAXIMUM_JSON_BYTES) return;
+		const copy = JSON.parse(json);
+		return isNonArrayObject(copy) && Object.keys(copy).length <= DETAILS_MAXIMUM_TOP_LEVEL_KEYS ? copy : void 0;
+	} catch {
+		return;
+	}
+};
+const reportableDetailsOf = (details) => {
+	if (!isGiven(details)) return { status: "not-given" };
+	const jsonCopy = jsonCopyWithinTheLimits(details);
+	if (jsonCopy === void 0) return {
+		status: "left-out",
+		warning: "details-not-reportable"
+	};
+	return {
+		status: "reportable",
+		fields: { details: jsonCopy }
+	};
+};
+const fieldsOf = (option) => option.status === "reportable" ? option.fields : void 0;
+const warningsOf = (...options) => options.flatMap((option) => option.status === "left-out" ? [option.warning] : []);
+const admitTrackedEvent = (call) => {
+	var _call$options, _call$options2;
+	if (!isWithinTheCharacterLimit(call.name)) return {
+		outcome: "dropped",
+		warnings: ["name-outside-the-character-limit"]
+	};
+	const value = reportableValueOf((_call$options = call.options) === null || _call$options === void 0 ? void 0 : _call$options.value);
+	const details = reportableDetailsOf((_call$options2 = call.options) === null || _call$options2 === void 0 ? void 0 : _call$options2.details);
+	return {
+		outcome: "admitted",
+		entry: {
+			name: call.name,
+			...reportedContextOf(call.context),
+			...fieldsOf(value),
+			...fieldsOf(details),
+			happenedAt: call.happenedAt.toISOString()
+		},
+		warnings: warningsOf(value, details)
+	};
+};
+//#endregion
 //#region ../js-client-core/src/cached-values.ts
 const ENTRY_FORMAT_VERSION = 2;
 const FIRST_ENTRY_FORMAT_VERSION = 1;
@@ -1836,7 +1952,7 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 		return this.evaluationOf(configKey, configState, defaultValue);
 	}
 	evaluationOf(configKey, configState, defaultValue) {
-		var _this$currentContext2, _parseResult$parsedVa;
+		var _this$currentContext2, _parseResult$variatio, _parseResult$parsedVa;
 		if (!configState) {
 			var _this$currentContext;
 			this.logger.debug(`[ConfigDirectorClient] No config state found for '${configKey}', returning default value '${defaultValue}'`);
@@ -1871,12 +1987,16 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 			evaluatedValue: parseResult.parsedValue,
 			evaluatedValueId: parseResult.parsedValueId,
 			usedDefault: parseResult.usedDefault,
-			evaluationReason: reason
+			evaluationReason: reason,
+			ruleId: parseResult.ruleId,
+			shareId: parseResult.shareId,
+			variationId: (_parseResult$variatio = parseResult.variation) === null || _parseResult$variatio === void 0 ? void 0 : _parseResult$variatio.id
 		});
 		const evaluation = {
 			key: configKey,
 			value: parseResult.parsedValue,
 			valueId: (_parseResult$parsedVa = parseResult.parsedValueId) !== null && _parseResult$parsedVa !== void 0 ? _parseResult$parsedVa : void 0,
+			variation: parseResult.variation,
 			isDefaultValue: parseResult.usedDefault,
 			reason,
 			context: this.context
@@ -1919,6 +2039,19 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 	unwatchAll() {
 		this.handlersMap.clear();
 	}
+	track(eventName, options) {
+		try {
+			const context = this.currentContext;
+			this.telemetryClient.trackedEvent(admitTrackedEvent({
+				name: eventName,
+				context,
+				options,
+				happenedAt: /* @__PURE__ */ new Date()
+			}), context);
+		} catch (error) {
+			this.logger.warn("[ConfigDirectorClient] A tracked event was not reported because it could not be read: ", error);
+		}
+	}
 	pauseNetwork() {
 		switch (this.connectionPlan.kind) {
 			case "stay-offline": return;
@@ -1959,4 +2092,4 @@ var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 const INSTALLED_TEST_CLIENT_SLOT = Symbol.for("@configdirector/installed-test-client");
 const readInstalledTestClient = () => globalThis[INSTALLED_TEST_CLIENT_SLOT];
 //#endregion
-export { DEFAULT_CACHING_SIZE_LIMIT_BYTES as a, createDefaultLogger as c, ConfigDirectorConnectionError as d, ConfigDirectorValidationError as f, CACHED_VALUES_STORAGE_KEY_PREFIX as i, nativeValueConfigState as l, _defineProperty as m, readInstalledTestClient as n, fetchWithTimeout as o, Emitter as p, DefaultConfigDirectorClient as r, discardingTelemetryClient as s, INSTALLED_TEST_CLIENT_SLOT as t, isFetchErrorFatal as u };
+export { Emitter as _, DEFAULT_CACHING_SIZE_LIMIT_BYTES as a, trackedEventWarningMessages as c, discardingTelemetryClient as d, createDefaultLogger as f, ConfigDirectorValidationError as g, ConfigDirectorConnectionError as h, CACHED_VALUES_STORAGE_KEY_PREFIX as i, utf8ByteLength as l, isFetchErrorFatal as m, readInstalledTestClient as n, TRACKED_EVENTS_PER_BATCH as o, nativeValueConfigState as p, DefaultConfigDirectorClient as r, logBatchWarnings as s, INSTALLED_TEST_CLIENT_SLOT as t, fetchWithTimeout as u, _defineProperty as v };

package/dist/{types-DmbDeZqL.d.mts → types-BCVhD8m2.d.mts}

@@ -25,24 +25,72 @@ interface ConfigDirectorLogMessageDecorator {
 }
 /**
  * Why an evaluation returned the value it did. `found-match` returns a value from ConfigDirector,
- * and `cached` a value kept on the device while a client SDK waits for live values. `value-missing`
+ * and `cached` a value kept on the device while a client SDK waits for live values.
+ * `rollout-skipped-no-identifier` returns the default targeting rule value: a server SDK skipped a
+ * percentage rollout because the context has no `id` to place it in a share. `value-missing`
  * returns the in-code default value because the config has no value. Every other reason returns the
  * in-code default value because of an error: the config does not exist (`config-state-missing`), no
  * values have arrived yet (`client-not-ready`), or the value cannot be read as the type of the in-code
  * default value.
  */
-type EvaluationReason = "found-match" | "config-state-missing" | "client-not-ready" | "type-mismatch" | "value-missing" | "invalid-number" | "invalid-json" | "invalid-boolean" | "cached";
+type EvaluationReason = "found-match" | "rollout-skipped-no-identifier" | "config-state-missing" | "client-not-ready" | "type-mismatch" | "value-missing" | "invalid-number" | "invalid-json" | "invalid-boolean" | "cached";
+/**
+ * One of the values a config can serve, such as the control or a treatment of an experiment.
+ */
+type Variation = {
+  /** The ID ConfigDirector assigned to the variation, which stays the same when it is renamed. */id: string; /** The variation's name, when it has one. */
+  name?: string;
+};
 /**
  * One evaluation of a config: the value it returned, why, and the context it was evaluated for.
  */
 type ConfigEvaluation<T extends ConfigValueType = ConfigValueType> = {
   /** The config key that was evaluated. */key: string; /** The value returned, which is the in-code default value when {@link isDefaultValue} is `true`. */
   value: T; /** The ID ConfigDirector assigned to the value returned, when ConfigDirector sent one with it. */
-  valueId?: string; /** Whether the evaluation returned the in-code default value. */
+  valueId?: string;
+  /**
+   * The variation that was served. It is `undefined` when the config has no variations or the
+   * in-code default value is returned.
+   */
+  variation?: Variation; /** Whether the evaluation returned the in-code default value. */
   isDefaultValue: boolean; /** Why the evaluation returned this value. */
   reason: EvaluationReason; /** The context the config was evaluated for, if any. */
   context?: ConfigDirectorContext;
 };
+/**
+ * A value in the details of a tracked event: a string, a number, a boolean, or an array or object
+ * of such values.
+ */
+type TrackedEventDetailValue = string | number | boolean | TrackedEventDetailValue[] | {
+  [key: string]: TrackedEventDetailValue;
+};
+/**
+ * Details of a tracked event, such as the plan a customer chose. Details with more than 20
+ * top-level keys, or larger than 1 KB as JSON, are left out and the event is still reported.
+ */
+type TrackedEventDetails = {
+  [key: string]: TrackedEventDetailValue;
+};
+/**
+ * What a tracked event carries besides its name.
+ */
+type TrackOptions = {
+  /**
+   * A number the event measures, such as an amount of money, a count or a duration. A value that
+   * is not a finite number is left out and the event is still reported.
+   */
+  value?: number; /** Details of the event. */
+  details?: TrackedEventDetails;
+};
+/**
+ * An event the code under test tracked, as a test client recorded it.
+ */
+type TrackedEvent = {
+  /** The name the event was tracked with. */name: string; /** The context the event was tracked for, if any. */
+  context?: ConfigDirectorContext; /** The value the event was tracked with, when it is a finite number. */
+  value?: number; /** The details the event was tracked with, when they are within the limits. */
+  details?: TrackedEventDetails;
+};
 /**
  * The context to be sent to ConfigDirector: the user or other entity, such as a device or an
  * organization, that configs are evaluated for. This context will be used for targeting rules
@@ -363,8 +411,8 @@ interface ConfigDirectorClient extends EventProvider<ClientEvents> {
   getValue<T extends ConfigValueType>(configKey: string, defaultValue: T): T;
   /**
    * Evaluates a config as {@link getValue} does and returns the evaluation: the value, the reason it
-   * was served and its value ID. Like every read, it fires `configEvaluated` and is counted in
-   * telemetry.
+   * was served, its value ID and its variation. Like every read, it fires `configEvaluated` and is
+   * counted in telemetry.
    *
    * @returns The evaluation, whose `value` is what {@link getValue} returns
    * @param configKey The config key to evaluate
@@ -396,6 +444,20 @@ interface ConfigDirectorClient extends EventProvider<ClientEvents> {
    * Removes all subscribers from all config keys
    */
   unwatchAll(): void;
+  /**
+   * Reports to ConfigDirector that something happened for the current context, such as a completed
+   * checkout, so it can be counted. The event is sent with the next telemetry batch. `track` never
+   * throws, and does nothing in `offline` mode.
+   *
+   * An event counts for an experiment only when the current context has an `id`, the one the
+   * experiment's config was evaluated for. Before the client has a context, or for a context
+   * without an `id`, the event is still reported.
+   *
+   * @param eventName The name of the event, 1 to 150 characters. An event with any other name is
+   * not reported and a warning is logged.
+   * @param options The event's {@link TrackOptions.value} and {@link TrackOptions.details} (optional)
+   */
+  track(eventName: string, options?: TrackOptions): void;
   /**
    * Pauses the network connection without clearing event handlers, watch handlers, or config
    * state. Intended for mobile environments where the OS may kill background connections (e.g.
@@ -418,4 +480,4 @@ interface ConfigDirectorClient extends EventProvider<ClientEvents> {
   dispose(): void;
 }
 //#endregion
-export { ConnectionMode as _, ConfigDirectorClientOptions as a, NativeJsonValue as c, ConfigDirectorContext as d, ConfigDirectorLogMessageDecorator as f, ConfigValueType as g, ConfigEvaluation as h, ConfigDirectorClient as i, NativeValue as l, ConfigDirectorLoggingLevel as m, CachingProvider as n, OfflineValue as o, ConfigDirectorLogger as p, ClientHooks as r, OfflineValues as s, CachingOptions as t, NativeValues as u, EvaluationReason as v };
+export { Variation as C, TrackedEventDetails as S, ConnectionMode as _, ConfigDirectorClientOptions as a, TrackedEvent as b, NativeJsonValue as c, ConfigDirectorContext as d, ConfigDirectorLogMessageDecorator as f, ConfigValueType as g, ConfigEvaluation as h, ConfigDirectorClient as i, NativeValue as l, ConfigDirectorLoggingLevel as m, CachingProvider as n, OfflineValue as o, ConfigDirectorLogger as p, ClientHooks as r, OfflineValues as s, CachingOptions as t, NativeValues as u, EvaluationReason as v, TrackedEventDetailValue as x, TrackOptions as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@configdirector/react-native-sdk",
-  "version": "1.10.1",
+  "version": "1.11.0",
   "description": "React Native client SDK for ConfigDirector. ConfigDirector is a remote configuration and feature flag service.",
   "license": "MIT",
   "author": "ConfigDirector",