From d4ff57edd808c119808652ee2d2085f343b00bec Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Mon, 6 Oct 2025 10:05:19 -0700 Subject: [PATCH 1/5] feat: add setTrackAssignmentEvent --- __tests__/client.test.ts | 160 +++++++++++++++++++++++++++++++++++++++ package.json | 2 +- src/experimentClient.ts | 23 ++++++ src/storage/cache.ts | 43 ++++++++++- yarn.lock | 8 +- 5 files changed, 230 insertions(+), 6 deletions(-) diff --git a/__tests__/client.test.ts b/__tests__/client.test.ts index 0aa4b92..0835aea 100644 --- a/__tests__/client.test.ts +++ b/__tests__/client.test.ts @@ -1051,3 +1051,163 @@ describe('fetch retry with different response codes', () => { }, ); }); + +describe('setTrackAssignmentEvent', () => { + beforeEach(async () => { + await AsyncStorage.clear(); + jest.restoreAllMocks(); + }); + + afterEach(() => { + jest.restoreAllMocks(); + }); + + test('setTrackAssignmentEvent(boolean) sets trackingOption to track and getVariants is called with correct options', async () => { + const client = new ExperimentClient(API_KEY, {}); + + // Mock the evaluationApi.getVariants method + const getVariantsSpy = jest.spyOn( + (client as any).evaluationApi, + 'getVariants', + ); + getVariantsSpy.mockResolvedValue({ + 'test-flag': { key: 'on', value: 'on' }, + }); + + // Set track assignment event to true + await client.setTrackAssignmentEvent(true); + + // Fetch variants to trigger the API call + await client.fetch(testUser); + + // Verify getVariants was called with trackingOption: 'track' + expect(getVariantsSpy).toHaveBeenCalledWith( + expect.objectContaining({ + user_id: testUser.user_id, + library: expect.stringContaining('experiment-react-native-client'), + }), + expect.objectContaining({ + trackingOption: 'track', + timeoutMillis: expect.any(Number), + }), + ); + + // Set track assignment event to false + await client.setTrackAssignmentEvent(false); + + // Fetch variants to trigger the API call + await client.fetch(testUser); + + // Verify getVariants was called with trackingOption: 'no-track' + expect(getVariantsSpy).toHaveBeenCalledWith( + expect.objectContaining({ + user_id: testUser.user_id, + library: expect.stringContaining('experiment-react-native-client'), + }), + expect.objectContaining({ + trackingOption: 'no-track', + timeoutMillis: expect.any(Number), + }), + ); + }); + + test('setTrackAssignmentEvent persists the setting to storage', async () => { + const client = new ExperimentClient(API_KEY, {}); + + // Set track assignment event to true + await client.setTrackAssignmentEvent(true); + + // Create a new client instance to verify persistence + const client2 = new ExperimentClient(API_KEY, {}); + await client2.cacheReady(); + + // Mock the evaluationApi.getVariants method for the second client + const getVariantsSpy = jest.spyOn( + (client2 as any).evaluationApi, + 'getVariants', + ); + getVariantsSpy.mockResolvedValue({ + 'test-flag': { key: 'on', value: 'on' }, + }); + + // Fetch variants with the second client + await client2.fetch(testUser); + + // Verify the setting was persisted and loaded by the second client + expect(getVariantsSpy).toHaveBeenCalledWith( + expect.objectContaining({ + user_id: testUser.user_id, + library: expect.stringContaining('experiment-react-native-client'), + }), + expect.objectContaining({ + trackingOption: 'track', + timeoutMillis: expect.any(Number), + }), + ); + }); + + test('multiple calls to setTrackAssignmentEvent uses the latest setting', async () => { + const client = new ExperimentClient(API_KEY, {}); + + // Mock the evaluationApi.getVariants method + const getVariantsSpy = jest.spyOn( + (client as any).evaluationApi, + 'getVariants', + ); + getVariantsSpy.mockResolvedValue({ + 'test-flag': { key: 'off', value: 'off' }, + }); + + // Set track assignment event to true, then false + await client.setTrackAssignmentEvent(true); + await client.setTrackAssignmentEvent(false); + + // Fetch variants to trigger the API call + await client.fetch(testUser); + + // Verify getVariants was called with the latest setting (no-track) + expect(getVariantsSpy).toHaveBeenCalledWith( + expect.objectContaining({ + user_id: testUser.user_id, + library: expect.stringContaining('experiment-react-native-client'), + }), + expect.objectContaining({ + trackingOption: 'no-track', + timeoutMillis: expect.any(Number), + }), + ); + }); + + test('setTrackAssignmentEvent preserves other existing options while updating trackingOption', async () => { + const client = new ExperimentClient(API_KEY, {}); + + // Mock the evaluationApi.getVariants method + const getVariantsSpy = jest.spyOn( + (client as any).evaluationApi, + 'getVariants', + ); + getVariantsSpy.mockResolvedValue({ + 'test-flag': { key: 'on', value: 'on' }, + }); + + // Set track assignment event to true + await client.setTrackAssignmentEvent(true); + + // Fetch variants with specific flag keys to ensure other options are preserved + const fetchOptions = { flagKeys: ['test-flag'] }; + await client.fetch(testUser, fetchOptions); + + // Verify getVariants was called with both trackingOption and flagKeys + expect(getVariantsSpy).toHaveBeenCalledWith( + expect.objectContaining({ + user_id: testUser.user_id, + library: expect.stringContaining('experiment-react-native-client'), + }), + expect.objectContaining({ + trackingOption: 'track', + flagKeys: ['test-flag'], + timeoutMillis: expect.any(Number), + }), + ); + }); +}); diff --git a/package.json b/package.json index 71053e8..a3e36c3 100644 --- a/package.json +++ b/package.json @@ -48,7 +48,7 @@ }, "dependencies": { "@amplitude/analytics-connector": "^1.4.7", - "@amplitude/experiment-core": "^0.7.2", + "@amplitude/experiment-core": "^0.10.0", "@react-native-async-storage/async-storage": "^1.17.6", "unfetch": "^4.2.0" }, diff --git a/src/experimentClient.ts b/src/experimentClient.ts index 5323456..f116fa0 100644 --- a/src/experimentClient.ts +++ b/src/experimentClient.ts @@ -13,6 +13,7 @@ import { Poller, SdkFlagApi, SdkEvaluationApi, + GetVariantsOptions, } from '@amplitude/experiment-core'; import { version as PACKAGE_VERSION } from './gen/version'; @@ -20,8 +21,10 @@ import { ConnectorUserProvider } from './integration/connector'; import { DefaultUserProvider } from './integration/default'; import { getFlagStorage, + getVariantsOptionsStorage, getVariantStorage, LoadStoreCache, + SingleValueStoreCache, } from './storage/cache'; import { LocalStorage } from './storage/local-storage'; import { FetchHttpClient, WrapperClient } from './transport/http'; @@ -81,6 +84,7 @@ export class ExperimentClient implements Client { private isRunning = false; private readonly flagsAndVariantsLoadedPromise: Promise[] | undefined; private readonly initialFlags: EvaluationFlag[] | undefined; + private readonly fetchVariantsOptions: SingleValueStoreCache; /** * Creates a new ExperimentClient instance. @@ -142,9 +146,15 @@ export class ExperimentClient implements Client { if (this.config.initialFlags) { this.initialFlags = JSON.parse(this.config.initialFlags); } + this.fetchVariantsOptions = getVariantsOptionsStorage( + this.apiKey, + this.config.instanceName, + storage, + ); this.flagsAndVariantsLoadedPromise = [ this.flags.load(this.convertInitialFlagsForStorage()), this.variants.load(), + this.fetchVariantsOptions.load(), ]; } @@ -387,6 +397,18 @@ export class ExperimentClient implements Client { return this; } + /** + * Set to track assignment event or not for fetching variants. + * @param doTrack + */ + public async setTrackAssignmentEvent(doTrack: boolean): Promise { + this.fetchVariantsOptions.put({ + ...this.fetchVariantsOptions.get(), + trackingOption: doTrack ? 'track' : 'no-track', + }); + this.fetchVariantsOptions.store(); + } + private convertInitialFlagsForStorage(): Record { if (this.initialFlags) { const flagsMap: Record = {}; @@ -666,6 +688,7 @@ export class ExperimentClient implements Client { user = await this.addContextOrWait(user, 10000); this.debug('[Experiment] Fetch variants for user: ', user); const results = await this.evaluationApi.getVariants(user, { + ...this.fetchVariantsOptions.get(), timeoutMillis: timeoutMillis, flagKeys: options?.flagKeys, }); diff --git a/src/storage/cache.ts b/src/storage/cache.ts index 1b9960b..9f40c05 100644 --- a/src/storage/cache.ts +++ b/src/storage/cache.ts @@ -1,4 +1,4 @@ -import { EvaluationFlag } from '@amplitude/experiment-core'; +import { EvaluationFlag, GetVariantsOptions } from '@amplitude/experiment-core'; import { Storage } from '../types/storage'; import { Variant } from '../types/variant'; @@ -29,6 +29,47 @@ export const getFlagStorage = ( return new LoadStoreCache(namespace, storage); }; +export const getVariantsOptionsStorage = ( + deploymentKey: string, + instanceName: string, + storage: Storage = new LocalStorage(), +): SingleValueStoreCache => { + const truncatedDeployment = deploymentKey.substring(deploymentKey.length - 6); + const namespace = `amp-exp-${instanceName}-${truncatedDeployment}-variants-options`; + return new SingleValueStoreCache(namespace, storage); +}; + +export class SingleValueStoreCache { + private readonly namespace: string; + private readonly storage: Storage; + private value: V | undefined; + + constructor(namespace: string, storage: Storage) { + this.namespace = namespace; + this.storage = storage; + this.value = this.get(); + } + + public get(): V | undefined { + return this.value; + } + + public put(value: V): void { + this.value = value; + } + + public async load(): Promise { + const value = await this.storage.get(this.namespace); + if (value) { + this.value = JSON.parse(value); + } + } + + public async store(): Promise { + await this.storage.put(this.namespace, JSON.stringify(this.value)); + } +} + export class LoadStoreCache { private readonly namespace: string; private readonly storage: Storage; diff --git a/yarn.lock b/yarn.lock index df54e43..4b6e8cf 100644 --- a/yarn.lock +++ b/yarn.lock @@ -14,10 +14,10 @@ dependencies: "@amplitude/ua-parser-js" "^0.7.31" -"@amplitude/experiment-core@^0.7.2": - version "0.7.2" - resolved "https://registry.yarnpkg.com/@amplitude/experiment-core/-/experiment-core-0.7.2.tgz#f94219d68d86322e8d580c8fbe0672dcd29f86bb" - integrity sha512-Wc2NWvgQ+bLJLeF0A9wBSPIaw0XuqqgkPKsoNFQrmS7r5Djd56um75In05tqmVntPJZRvGKU46pAp8o5tdf4mA== +"@amplitude/experiment-core@^0.10.0": + version "0.10.1" + resolved "https://registry.yarnpkg.com/@amplitude/experiment-core/-/experiment-core-0.10.1.tgz#85bb0bf55b419fe1b7bcee428182ed1eda010ff3" + integrity sha512-2h0vqOaHoACmNiliGT78hnu9K/tmb7pWU1xw1KitlTtxK6wQqsY/IZPLMwBMG5MLp/AOzNEA/uelODfhBC5+SQ== dependencies: js-base64 "^3.7.5" From 021fb7890676cc6a3f9d814d691262d61528e559 Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Mon, 6 Oct 2025 17:12:14 -0700 Subject: [PATCH 2/5] fix: add undefined handling --- src/experimentClient.ts | 1 + src/storage/cache.ts | 8 +++++++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/experimentClient.ts b/src/experimentClient.ts index f116fa0..afabbec 100644 --- a/src/experimentClient.ts +++ b/src/experimentClient.ts @@ -406,6 +406,7 @@ export class ExperimentClient implements Client { ...this.fetchVariantsOptions.get(), trackingOption: doTrack ? 'track' : 'no-track', }); + // No need to wait for persistence to complete. this.fetchVariantsOptions.store(); } diff --git a/src/storage/cache.ts b/src/storage/cache.ts index 9f40c05..6c761ce 100644 --- a/src/storage/cache.ts +++ b/src/storage/cache.ts @@ -66,7 +66,13 @@ export class SingleValueStoreCache { } public async store(): Promise { - await this.storage.put(this.namespace, JSON.stringify(this.value)); + if (this.value === undefined) { + // Delete the key if the value is undefined + await this.storage.delete(this.namespace); + } else { + // Also store false or null values + await this.storage.put(this.namespace, JSON.stringify(this.value)); + } } } From f6c59d02e284cb689695d8cb9eabfb34f929aa20 Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Tue, 28 Oct 2025 10:26:28 -0700 Subject: [PATCH 3/5] fix: evaluationId tests --- __tests__/client.test.ts | 32 ++++++++++++++++++-------------- package.json | 2 +- yarn.lock | 8 ++++---- 3 files changed, 23 insertions(+), 19 deletions(-) diff --git a/__tests__/client.test.ts b/__tests__/client.test.ts index 0835aea..86bb208 100644 --- a/__tests__/client.test.ts +++ b/__tests__/client.test.ts @@ -70,7 +70,7 @@ test('ExperimentClient.fetch, success', async () => { const client = new ExperimentClient(API_KEY, {}); await client.fetch(testUser); const variant = client.variant(serverKey); - expect(variant).toEqual(serverVariant); + expect(variant).toMatchObject(serverVariant); }); /** @@ -101,7 +101,7 @@ test('ExperimentClient.fetch, with retries, retry success', async () => { expect(variant).toEqual(fallbackVariant); await delay(2000); variant = client.variant(serverKey); - expect(variant).toEqual(serverVariant); + expect(variant).toMatchObject(serverVariant); }); /** @@ -166,7 +166,7 @@ test('ExperimentClient.variant, initial variants fallback before fetch, no fallb expect(variant).toEqual(initialVariant); variant = client.variant(serverKey); - expect(variant).toEqual(serverVariant); + expect(variant).toMatchObject(serverVariant); }); /** @@ -220,7 +220,7 @@ test('ExperimentClient.fetch, with user provider, success', async () => { ); await client.fetch(); const variant = client.variant('sdk-ci-test'); - expect(variant).toEqual({ key: 'on', value: 'on', payload: 'payload' }); + expect(variant).toMatchObject({ key: 'on', value: 'on', payload: 'payload' }); }); /** @@ -233,7 +233,7 @@ test('ExperimentClient.fetch, with config user provider, success', async () => { }); await client.fetch(); const variant = client.variant('sdk-ci-test'); - expect(variant).toEqual({ key: 'on', value: 'on', payload: 'payload' }); + expect(variant).toMatchObject({ key: 'on', value: 'on', payload: 'payload' }); }); /** @@ -266,11 +266,13 @@ test('ExperimentClient.variant, with exposure tracking provider, track called on for (let i = 0; i < 10; i++) { client.variant(serverKey); } + const variant = client.variant(serverKey); expect(trackSpy).toBeCalledTimes(1); expect(trackSpy).toHaveBeenCalledWith({ flag_key: serverKey, variant: serverVariant.value, + metadata: variant.metadata, }); expect(logEventSpy).toBeCalledTimes(1); expect(logEventSpy).toHaveBeenCalledWith({ @@ -278,6 +280,7 @@ test('ExperimentClient.variant, with exposure tracking provider, track called on eventProperties: { flag_key: serverKey, variant: serverVariant.value, + metadata: variant.metadata, }, }); }); @@ -293,13 +296,14 @@ test('ExperimentClient.variant, with analytics provider, exposure tracked, unset exposureTrackingProvider: exposureTrackingProvider, }); await client.fetch(testUser); - client.variant(serverKey); + const variant = client.variant(serverKey); expect(spyTrack).toBeCalledTimes(1); const expectedEvent = { flag_key: serverKey, variant: serverVariant.value, + metadata: variant.metadata, }; expect(spyTrack).lastCalledWith(expectedEvent); }); @@ -320,7 +324,7 @@ test('ExperimentClient.clear, clear all variants in the cache and storage', asyn const client = new ExperimentClient(API_KEY, {}); await client.fetch(testUser); const variant = client.variant(serverKey); - expect(variant).toEqual(serverVariant); + expect(variant).toMatchObject(serverVariant); client.clear(); const clearedVariants = client.all(); @@ -352,7 +356,7 @@ test('ExperimentClient.fetch with partial flag keys in fetch options, should ret const option: FetchOptions = { flagKeys: ['sdk-ci-test'] }; await client.fetch(testUser, option); const variants = client.all(); - expect(variants).toEqual(flagKeysTestVariantPartial); + expect(variants).toMatchObject(flagKeysTestVariantPartial); }); test('ExperimentClient.fetch with partial flag keys in fetch options, should return the fetched variant', async () => { @@ -360,7 +364,7 @@ test('ExperimentClient.fetch with partial flag keys in fetch options, should ret const option: FetchOptions = { flagKeys: ['sdk-ci-test'] }; await client.fetch(testUser, option); const variant = client.all(); - expect(variant).toEqual(flagKeysTestVariantPartial); + expect(variant).toMatchObject(flagKeysTestVariantPartial); }); test('ExperimentClient.fetch without fetch options, should return all variants', async () => { @@ -434,7 +438,7 @@ describe('local evaluation', () => { expect(variant.value).toBeUndefined(); await client.fetch(user); variant = client.variant('sdk-ci-test'); - expect(variant).toEqual({ + expect(variant).toMatchObject({ key: 'on', value: 'on', payload: 'payload', @@ -662,7 +666,7 @@ describe('variant fallbacks', () => { await client.start(user); // Variant is result of inline fallback string const variantString = client.variant('sdk-ci-test', 'inline'); - expect(variantString).toEqual({ + expect(variantString).toMatchObject({ key: 'on', value: 'on', payload: 'payload', @@ -692,7 +696,7 @@ describe('variant fallbacks', () => { expect(variantString).toEqual({ key: 'inline', value: 'inline' }); // Variant is result of inline fallback object const variantObject = client.variant('sdk-ci-test', { value: 'inline' }); - expect(variantObject).toEqual({ value: 'inline' }); + expect(variantObject).toMatchObject({ value: 'inline' }); expect(spy).toHaveBeenCalledTimes(1); expect((spy.mock.calls[0] as any[])[0].flag_key).toEqual('sdk-ci-test'); expect((spy.mock.calls[0] as any[])[0].variant).toBeUndefined(); @@ -715,7 +719,7 @@ describe('variant fallbacks', () => { await client.start(user); const variant = client.variant('sdk-ci-test'); // Variant is result of fallbackVariant - expect(variant).toEqual({ key: 'fallback', value: 'fallback' }); + expect(variant).toMatchObject({ key: 'fallback', value: 'fallback' }); expect(spy).toHaveBeenCalledTimes(1); expect((spy.mock.calls[0] as any[])[0].flag_key).toEqual('sdk-ci-test'); expect((spy.mock.calls[0] as any[])[0].variant).toBeUndefined(); @@ -736,7 +740,7 @@ describe('variant fallbacks', () => { // Start and fetch await client.start(user); const variant = client.variant('sdk-ci-test'); - expect(variant).toEqual({ + expect(variant).toMatchObject({ key: 'off', metadata: { default: true }, }); diff --git a/package.json b/package.json index a3e36c3..3d0a1f5 100644 --- a/package.json +++ b/package.json @@ -48,7 +48,7 @@ }, "dependencies": { "@amplitude/analytics-connector": "^1.4.7", - "@amplitude/experiment-core": "^0.10.0", + "@amplitude/experiment-core": "^0.11.0", "@react-native-async-storage/async-storage": "^1.17.6", "unfetch": "^4.2.0" }, diff --git a/yarn.lock b/yarn.lock index 4b6e8cf..0cee6bd 100644 --- a/yarn.lock +++ b/yarn.lock @@ -14,10 +14,10 @@ dependencies: "@amplitude/ua-parser-js" "^0.7.31" -"@amplitude/experiment-core@^0.10.0": - version "0.10.1" - resolved "https://registry.yarnpkg.com/@amplitude/experiment-core/-/experiment-core-0.10.1.tgz#85bb0bf55b419fe1b7bcee428182ed1eda010ff3" - integrity sha512-2h0vqOaHoACmNiliGT78hnu9K/tmb7pWU1xw1KitlTtxK6wQqsY/IZPLMwBMG5MLp/AOzNEA/uelODfhBC5+SQ== +"@amplitude/experiment-core@^0.11.0": + version "0.11.1" + resolved "https://registry.yarnpkg.com/@amplitude/experiment-core/-/experiment-core-0.11.1.tgz#31eb485dc40b65f4cc2f15adab9b62f0df622065" + integrity sha512-fHVJazCwwgjUcj49N+yFSLMSroyY0eHImrsmd1ipIjIT1Cez8mh+TvwJQ0LGSdyYvL2NAZM2J5vpXrR1nHgdzg== dependencies: js-base64 "^3.7.5" From 197d1089a8a583a29036c7c9b8f0a65394693c51 Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Tue, 28 Oct 2025 12:54:30 -0700 Subject: [PATCH 4/5] feat: rename to setTracksAssignment --- __tests__/client.test.ts | 22 +++++++++++----------- src/experimentClient.ts | 2 +- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/__tests__/client.test.ts b/__tests__/client.test.ts index 86bb208..44860aa 100644 --- a/__tests__/client.test.ts +++ b/__tests__/client.test.ts @@ -1056,7 +1056,7 @@ describe('fetch retry with different response codes', () => { ); }); -describe('setTrackAssignmentEvent', () => { +describe('setTracksAssignment', () => { beforeEach(async () => { await AsyncStorage.clear(); jest.restoreAllMocks(); @@ -1066,7 +1066,7 @@ describe('setTrackAssignmentEvent', () => { jest.restoreAllMocks(); }); - test('setTrackAssignmentEvent(boolean) sets trackingOption to track and getVariants is called with correct options', async () => { + test('setTracksAssignment(boolean) sets trackingOption to track and getVariants is called with correct options', async () => { const client = new ExperimentClient(API_KEY, {}); // Mock the evaluationApi.getVariants method @@ -1079,7 +1079,7 @@ describe('setTrackAssignmentEvent', () => { }); // Set track assignment event to true - await client.setTrackAssignmentEvent(true); + await client.setTracksAssignment(true); // Fetch variants to trigger the API call await client.fetch(testUser); @@ -1097,7 +1097,7 @@ describe('setTrackAssignmentEvent', () => { ); // Set track assignment event to false - await client.setTrackAssignmentEvent(false); + await client.setTracksAssignment(false); // Fetch variants to trigger the API call await client.fetch(testUser); @@ -1115,11 +1115,11 @@ describe('setTrackAssignmentEvent', () => { ); }); - test('setTrackAssignmentEvent persists the setting to storage', async () => { + test('setTracksAssignment persists the setting to storage', async () => { const client = new ExperimentClient(API_KEY, {}); // Set track assignment event to true - await client.setTrackAssignmentEvent(true); + await client.setTracksAssignment(true); // Create a new client instance to verify persistence const client2 = new ExperimentClient(API_KEY, {}); @@ -1150,7 +1150,7 @@ describe('setTrackAssignmentEvent', () => { ); }); - test('multiple calls to setTrackAssignmentEvent uses the latest setting', async () => { + test('multiple calls to setTracksAssignment uses the latest setting', async () => { const client = new ExperimentClient(API_KEY, {}); // Mock the evaluationApi.getVariants method @@ -1163,8 +1163,8 @@ describe('setTrackAssignmentEvent', () => { }); // Set track assignment event to true, then false - await client.setTrackAssignmentEvent(true); - await client.setTrackAssignmentEvent(false); + await client.setTracksAssignment(true); + await client.setTracksAssignment(false); // Fetch variants to trigger the API call await client.fetch(testUser); @@ -1182,7 +1182,7 @@ describe('setTrackAssignmentEvent', () => { ); }); - test('setTrackAssignmentEvent preserves other existing options while updating trackingOption', async () => { + test('setTracksAssignment preserves other existing options while updating trackingOption', async () => { const client = new ExperimentClient(API_KEY, {}); // Mock the evaluationApi.getVariants method @@ -1195,7 +1195,7 @@ describe('setTrackAssignmentEvent', () => { }); // Set track assignment event to true - await client.setTrackAssignmentEvent(true); + await client.setTracksAssignment(true); // Fetch variants with specific flag keys to ensure other options are preserved const fetchOptions = { flagKeys: ['test-flag'] }; diff --git a/src/experimentClient.ts b/src/experimentClient.ts index afabbec..2fc3b2c 100644 --- a/src/experimentClient.ts +++ b/src/experimentClient.ts @@ -401,7 +401,7 @@ export class ExperimentClient implements Client { * Set to track assignment event or not for fetching variants. * @param doTrack */ - public async setTrackAssignmentEvent(doTrack: boolean): Promise { + public async setTracksAssignment(doTrack: boolean): Promise { this.fetchVariantsOptions.put({ ...this.fetchVariantsOptions.get(), trackingOption: doTrack ? 'track' : 'no-track', From 8c9df4ea7994259f7938bceca53b862b9e8caa1a Mon Sep 17 00:00:00 2001 From: Peter Zhu Date: Mon, 10 Nov 2025 14:29:05 -0800 Subject: [PATCH 5/5] fix: comment --- src/experimentClient.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/experimentClient.ts b/src/experimentClient.ts index 2fc3b2c..edebcca 100644 --- a/src/experimentClient.ts +++ b/src/experimentClient.ts @@ -398,8 +398,8 @@ export class ExperimentClient implements Client { } /** - * Set to track assignment event or not for fetching variants. - * @param doTrack + * Enables or disables tracking of assignment events when fetching variants. + * @param doTrack Whether to track assignment events. */ public async setTracksAssignment(doTrack: boolean): Promise { this.fetchVariantsOptions.put({