td-feature-node 0.0.0-stage → 0.0.2

package/dist/core/response.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseResponse = parseResponse;
+exports.parseSnapshot = parseSnapshot;
+const zlib_1 = require("zlib");
+const errors_1 = require("../errors");
+const json_1 = require("../common/json");
+const config_snapshot_1 = require("./config-snapshot");
+const stream_decoder_1 = require("./stream-decoder");
+function invalid(message, cause) {
+    return new errors_1.FeatureError(message, 'INVALID_RESPONSE', { errorCode: 5000, cause: cause });
+}
+function integer(value, fallback) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    if (typeof value === 'boolean')
+        return value ? 1 : 0;
+    if (typeof value === 'string' && /^[+-]?\d+$/.test(value))
+        value = Number(value);
+    if (typeof value !== 'number' || !isFinite(value) || Math.floor(value) !== value)
+        throw invalid('Expected an integer response field');
+    return value;
+}
+function expiration(outer, decoded) {
+    const info = decoded && (0, json_1.isObject)(decoded.templateInfo)
+        ? decoded.templateInfo
+        : (0, json_1.isObject)(outer.templateInfo)
+            ? outer.templateInfo
+            : null;
+    return info ? integer(info.expirationPeriod, 0) : 86400;
+}
+function control(value) {
+    if (value === undefined ||
+        value === null ||
+        value === '' ||
+        value === false ||
+        value === 'false' ||
+        value === '0')
+        return false;
+    if (value === true || value === 'true' || value === '1')
+        return true;
+    if (typeof value === 'number')
+        return value === 1;
+    throw invalid('Invalid #is_control_group');
+}
+function experiment(value) {
+    if (!(0, json_1.isObject)(value))
+        throw invalid('experiment_detail entries must be objects');
+    let bucket = null;
+    if (value.bucket_id !== undefined && value.bucket_id !== null) {
+        if (!(0, json_1.isObject)(value.bucket_id))
+            throw invalid('bucket_id must be an object');
+        bucket = Object.create(null);
+        Object.keys(value.bucket_id).forEach(function (key) {
+            bucket[key] = (0, json_1.stringValue)(value.bucket_id[key]);
+        });
+        Object.freeze(bucket);
+    }
+    let list = null;
+    if (value['#feature_list'] !== undefined && value['#feature_list'] !== null) {
+        if (!Array.isArray(value['#feature_list']))
+            throw invalid('#feature_list must be an array');
+        list = Object.freeze(value['#feature_list'].map(json_1.stringValue));
+    }
+    return Object.freeze({
+        experimentId: (0, json_1.stringValue)(value['#experiment_id']),
+        experimentGroupId: (0, json_1.stringValue)(value['#experiment_group_id']),
+        isControlGroup: control(value['#is_control_group']),
+        bucketId: bucket,
+        featureList: list,
+    });
+}
+function features(outer, decoded) {
+    const container = (0, json_1.isObject)(decoded.config) ? decoded.config : decoded;
+    const source = container.ta_feature;
+    const ttl = expiration(outer, decoded);
+    if (source === undefined || source === null)
+        return (0, config_snapshot_1.makeSnapshot)([], ttl);
+    if (!(0, json_1.isObject)(source))
+        throw invalid('ta_feature must be an object');
+    const byFeature = new Map();
+    const detail = source.experiment_detail;
+    if (detail !== undefined && detail !== null) {
+        if (!Array.isArray(detail))
+            throw invalid('experiment_detail must be an array');
+        detail.forEach(function (entry) {
+            const info = experiment(entry);
+            if (info.featureList)
+                info.featureList.forEach(function (key) {
+                    if (key !== null && !byFeature.has(key))
+                        byFeature.set(key, info);
+                });
+        });
+    }
+    return (0, config_snapshot_1.makeSnapshot)(Object.keys(source)
+        .filter(function (key) {
+        return key !== 'experiment_detail';
+    })
+        .map(function (key) {
+        return { key: key, value: source[key], experimentInfo: byFeature.get(key) || null };
+    }), ttl);
+}
+function parseResponse(text, limit, accountId, distinctId) {
+    return parseSnapshot(text, limit).then(function (snapshot) {
+        return (0, config_snapshot_1.bindSnapshot)(snapshot, accountId, distinctId);
+    });
+}
+function parseSnapshot(text, limit, operation) {
+    let outer;
+    let compressed;
+    try {
+        if (operation)
+            operation.check();
+        const parsed = JSON.parse(text);
+        if (operation)
+            operation.check();
+        if (!(0, json_1.isObject)(parsed))
+            throw invalid('Remote response must be a JSON object');
+        outer = parsed;
+        const code = integer(outer.code, 0);
+        if (code !== 0) {
+            const known = [1001, 1002, 1003, 1004, 2001, 2002, 5000].indexOf(code) >= 0 ? code : 5000;
+            throw new errors_1.FeatureError((0, json_1.stringValue)(outer.message) || (0, json_1.stringValue)(outer.msg) || 'Remote Config error ' + code, 'REMOTE_ERROR', { remoteCode: code, errorCode: known });
+        }
+        compressed = (0, json_1.stringValue)(outer.data);
+        if (compressed === null || compressed === '')
+            return Promise.resolve((0, config_snapshot_1.makeSnapshot)([], expiration(outer)));
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(compressed) ||
+            compressed.length % 4 === 1 ||
+            (compressed.indexOf('=') >= 0 && compressed.length % 4 !== 0))
+            throw invalid('Invalid Base64 response data');
+    }
+    catch (error) {
+        return Promise.reject(error instanceof errors_1.FeatureError ? error : invalid('Invalid response envelope', error));
+    }
+    return new Promise((resolve, reject) => {
+        const decoder = new stream_decoder_1.Decoder((0, zlib_1.createGunzip)());
+        const gunzip = decoder.stream;
+        let settled = false;
+        let size = 0;
+        const chunks = [];
+        let unsubscribe = function () { };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            unsubscribe();
+            decoder.stop();
+            reject(error);
+        };
+        gunzip.on('error', (error) => fail(invalid('Failed to decompress response data', error)));
+        gunzip.on('data', (chunk) => {
+            if (settled)
+                return;
+            try {
+                if (operation)
+                    operation.check();
+            }
+            catch (error) {
+                fail(error);
+                return;
+            }
+            size += chunk.length;
+            if (size > limit)
+                fail(new errors_1.FeatureError('Decompressed response exceeds maxDecompressedResponseBytes', 'RESPONSE_TOO_LARGE', { errorCode: 5000 }));
+            else
+                chunks.push(chunk);
+        });
+        gunzip.on('end', () => {
+            if (settled)
+                return;
+            try {
+                if (operation)
+                    operation.check();
+                const decoded = JSON.parse(Buffer.concat(chunks, size).toString('utf8'));
+                if (operation)
+                    operation.check();
+                if (!(0, json_1.isObject)(decoded))
+                    throw invalid('Decoded response must be a JSON object');
+                const result = features(outer, decoded);
+                if (operation)
+                    operation.check();
+                settled = true;
+                unsubscribe();
+                resolve(result);
+            }
+            catch (error) {
+                fail(error instanceof errors_1.FeatureError
+                    ? error
+                    : invalid('Invalid decoded configuration', error));
+            }
+        });
+        if (operation)
+            unsubscribe = operation.onCancel(fail);
+        if (!settled)
+            decoder.feed(Buffer.from(compressed, 'base64'), () => decoder.end());
+    });
+}

package/dist/core/result-cache.d.ts

@@ -0,0 +1,14 @@
+import { ConfigSnapshot } from './config-snapshot';
+export declare function configCacheKey(body: string): string;
+export declare class ResultCache {
+    private readonly maxEntries;
+    private readonly fallbackSeconds;
+    private readonly now;
+    private readonly entries;
+    constructor(maxEntries: number, fallbackSeconds: number, now?: () => number);
+    get(key: string): ConfigSnapshot | null;
+    set(key: string, snapshot: ConfigSnapshot): boolean;
+    removeIfSame(key: string, snapshot: ConfigSnapshot): void;
+    clear(): void;
+    get size(): number;
+}

package/dist/core/result-cache.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultCache = void 0;
+exports.configCacheKey = configCacheKey;
+const crypto_1 = require("crypto");
+const request_operation_1 = require("./request-operation");
+function canonical(value) {
+    if (Array.isArray(value))
+        return '[' + value.map(canonical).join(',') + ']';
+    if (value !== null && typeof value === 'object')
+        return ('{' +
+            Object.keys(value)
+                .sort()
+                .map(function (key) {
+                return JSON.stringify(key) + ':' + canonical(value[key]);
+            })
+                .join(',') +
+            '}');
+    return JSON.stringify(value);
+}
+function configCacheKey(body) {
+    const request = JSON.parse(body);
+    const keys = request.request_params['#feature_key'];
+    if (Array.isArray(keys))
+        request.request_params['#feature_key'] = keys.slice().sort();
+    return (0, crypto_1.createHash)('sha256').update(canonical(request), 'utf8').digest('hex');
+}
+class ResultCache {
+    constructor(maxEntries, fallbackSeconds, now = request_operation_1.monotonicNow) {
+        this.maxEntries = maxEntries;
+        this.fallbackSeconds = fallbackSeconds;
+        this.now = now;
+        this.entries = new Map();
+    }
+    get(key) {
+        const entry = this.entries.get(key);
+        if (!entry)
+            return null;
+        if (entry.expires <= this.now()) {
+            this.entries.delete(key);
+            return null;
+        }
+        this.entries.delete(key);
+        this.entries.set(key, entry);
+        return entry.snapshot;
+    }
+    set(key, snapshot) {
+        this.entries.delete(key);
+        const seconds = snapshot.expirationPeriod > 0 ? snapshot.expirationPeriod : this.fallbackSeconds;
+        if (this.maxEntries === 0 || seconds <= 0)
+            return false;
+        while (this.entries.size >= this.maxEntries) {
+            this.entries.delete(this.entries.keys().next().value);
+        }
+        this.entries.set(key, { snapshot, expires: this.now() + seconds * 1000 });
+        return true;
+    }
+    removeIfSame(key, snapshot) {
+        const entry = this.entries.get(key);
+        if (entry && entry.snapshot === snapshot)
+            this.entries.delete(key);
+    }
+    clear() {
+        this.entries.clear();
+    }
+    get size() {
+        return this.entries.size;
+    }
+}
+exports.ResultCache = ResultCache;

package/dist/core/retry.d.ts

@@ -0,0 +1,6 @@
+import { FeatureError } from '../errors';
+import type { ResolvedClientOptions } from '../types';
+export declare function retryable(error: Error): boolean;
+/** null means the server's minimum wait exceeds the configured retry limit. */
+export declare function retryDelay(retryIndex: number, error: FeatureError, config: Readonly<ResolvedClientOptions>): number | null;
+export declare function parseRetryAfter(value: string | string[] | undefined, now?: number): number | undefined;

package/dist/core/retry.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryable = retryable;
+exports.retryDelay = retryDelay;
+exports.parseRetryAfter = parseRetryAfter;
+const errors_1 = require("../errors");
+function retryable(error) {
+    if (!(error instanceof errors_1.FeatureError))
+        return false;
+    if (error.code === 'TIMEOUT')
+        return true;
+    if (error.code === 'HTTP_ERROR')
+        return [408, 429, 500, 502, 503, 504].indexOf(error.httpStatus || 0) >= 0;
+    if (error.code !== 'NETWORK_ERROR')
+        return false;
+    const cause = error.cause;
+    const code = cause && cause.code;
+    return (code === undefined ||
+        [
+            'ECONNRESET',
+            'ECONNREFUSED',
+            'EPIPE',
+            'ETIMEDOUT',
+            'ESOCKETTIMEDOUT',
+            'EAI_AGAIN',
+            'ECONNABORTED',
+            'ERR_SOCKET_CLOSED',
+            'ERR_STREAM_PREMATURE_CLOSE',
+        ].indexOf(code) >= 0);
+}
+/** null means the server's minimum wait exceeds the configured retry limit. */
+function retryDelay(retryIndex, error, config) {
+    const retryAfter = error.retryAfterMillis || 0;
+    if (retryAfter > config.maxRetryInterval)
+        return null;
+    const interval = config.retryInterval *
+        (config.retryStrategy === 'EXPONENTIAL_BACKOFF' ? Math.pow(2, retryIndex) : 1);
+    const capped = Math.min(config.maxRetryInterval, interval);
+    const backoff = config.retryJitter ? Math.floor(Math.random() * (capped + 1)) : capped;
+    return Math.max(backoff, retryAfter);
+}
+function parseRetryAfter(value, now = Date.now()) {
+    if (typeof value !== 'string')
+        return undefined;
+    if (/^\d+$/.test(value))
+        return Math.min(2147483647, Number(value) * 1000);
+    const date = Date.parse(value);
+    return isFinite(date) ? Math.max(0, Math.min(2147483647, date - now)) : undefined;
+}

package/dist/core/stream-decoder.d.ts

@@ -0,0 +1,10 @@
+import { Gunzip, Inflate } from 'zlib';
+/** Backpressure and cancellation for native HTTP and payload decompression. */
+export declare class Decoder {
+    readonly stream: Gunzip | Inflate;
+    private stopped;
+    constructor(stream: Gunzip | Inflate);
+    feed(input: Buffer, done: () => void): void;
+    end(): void;
+    stop(): void;
+}

package/dist/core/stream-decoder.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decoder = void 0;
+/** Backpressure and cancellation for native HTTP and payload decompression. */
+class Decoder {
+    constructor(stream) {
+        this.stream = stream;
+        this.stopped = false;
+    }
+    feed(input, done) {
+        if (this.stopped)
+            return;
+        this.stream.write(input, () => {
+            if (!this.stopped)
+                done();
+        });
+    }
+    end() {
+        if (!this.stopped)
+            this.stream.end();
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.stream.destroy();
+    }
+}
+exports.Decoder = Decoder;

package/dist/errors.d.ts

@@ -0,0 +1,17 @@
+export type FeatureErrorCode = 'INVALID_CONFIG' | 'INVALID_REQUEST' | 'NETWORK_ERROR' | 'HTTP_ERROR' | 'REMOTE_ERROR' | 'INVALID_RESPONSE' | 'RESPONSE_TOO_LARGE' | 'TIMEOUT' | 'CLIENT_CLOSED' | 'QUEUE_FULL' | 'ABORTED' | 'EXPOSURE_ERROR';
+export interface FeatureErrorDetails {
+    httpStatus?: number;
+    remoteCode?: number;
+    errorCode?: number;
+    cause?: Error;
+    retryAfterMillis?: number;
+}
+export declare class FeatureError extends Error {
+    readonly code: FeatureErrorCode;
+    readonly httpStatus: number | undefined;
+    readonly remoteCode: number | undefined;
+    readonly errorCode: number;
+    readonly cause: Error | undefined;
+    readonly retryAfterMillis: number | undefined;
+    constructor(message: string, code?: FeatureErrorCode, details?: FeatureErrorDetails);
+}

package/dist/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureError = void 0;
+class FeatureError extends Error {
+    constructor(message, code = 'INVALID_CONFIG', details = {}) {
+        super(message);
+        this.code = code;
+        this.name = 'FeatureError';
+        this.httpStatus = details.httpStatus;
+        this.remoteCode = details.remoteCode;
+        this.errorCode = details.errorCode === undefined ? -1 : details.errorCode;
+        this.cause = details.cause;
+        this.retryAfterMillis = details.retryAfterMillis;
+    }
+}
+exports.FeatureError = FeatureError;

package/dist/evaluation.d.ts

@@ -0,0 +1,10 @@
+import { Feature } from './feature';
+export interface Evaluation {
+    /** Missing keys resolve to undefined; reserved object keys are safe to look up. */
+    readonly features: Readonly<{
+        [key: string]: Feature | undefined;
+    }>;
+    /** Original RCC TTL in seconds, not the remaining cache lifetime. */
+    readonly ttl: number;
+}
+export declare function createEvaluation(results: Feature[], ttl: number): Evaluation;

package/dist/evaluation.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEvaluation = createEvaluation;
+function createEvaluation(results, ttl) {
+    const features = Object.create(null);
+    for (const feature of results)
+        features[feature.key] = feature;
+    return Object.freeze({ features: Object.freeze(features), ttl });
+}

package/dist/feature.d.ts

@@ -0,0 +1,31 @@
+import type { ExperimentInfo, JsonObject, JsonValue } from './types';
+interface ValueReader<T> {
+    (): T | null;
+    (fallback: T): T;
+    (fallback: T | null): T | null;
+}
+/** A request-scoped result. Reading a value may trigger opt-in automatic exposure. */
+export interface Feature {
+    readonly key: string;
+    readonly value: JsonValue;
+    readonly accountId: string | null;
+    readonly distinctId: string | null;
+    readonly experiment: ExperimentInfo | null;
+    readonly hasValue: boolean;
+    readonly asString: ValueReader<string>;
+    readonly asNumber: ValueReader<number>;
+    readonly asBoolean: ValueReader<boolean>;
+    asJson(fallback?: JsonObject | null): JsonObject | null;
+}
+interface FeatureOptions {
+    key: string;
+    value: JsonValue;
+    accountId: string | null;
+    distinctId: string | null;
+    experiment: ExperimentInfo | null;
+    onRead?: (feature: Feature) => void;
+}
+/** Internal factory: consumers obtain trusted results through client.fetch(). */
+export declare function createFeature(options: FeatureOptions): Feature;
+export declare function isFeature(value: unknown): value is Feature;
+export {};

package/dist/feature.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFeature = createFeature;
+exports.isFeature = isFeature;
+const json_1 = require("./common/json");
+const coercion_1 = require("./common/coercion");
+const results = new WeakSet();
+/** Internal factory: consumers obtain trusted results through client.fetch(). */
+function createFeature(options) {
+    const { key, value, accountId, distinctId, experiment, onRead } = options;
+    const raw = (0, json_1.freezeJson)(value);
+    let triggered = false;
+    function read(result) {
+        if (onRead && experiment && !triggered) {
+            triggered = true;
+            // Collection failures never change a business value or its fallback.
+            try {
+                onRead(feature);
+            }
+            catch (_) { }
+        }
+        return result;
+    }
+    function asString(fallback = null) {
+        return read(value === null ? fallback : (0, json_1.stringValue)(value));
+    }
+    function asNumber(fallback = null) {
+        return read((0, coercion_1.toNumber)(value, fallback));
+    }
+    function asBoolean(fallback = null) {
+        return read((0, coercion_1.toBoolean)(value, fallback));
+    }
+    const feature = Object.freeze({
+        key,
+        get value() {
+            return read(raw);
+        },
+        accountId,
+        distinctId,
+        experiment,
+        hasValue: raw !== null,
+        asString,
+        asNumber,
+        asBoolean,
+        asJson(fallback = null) {
+            // Reuse the same immutable JSON value on repeated reads.
+            return read(raw !== null && typeof raw === 'object' && !Array.isArray(raw)
+                ? raw
+                : (0, coercion_1.toJson)(value, fallback));
+        },
+    });
+    results.add(feature);
+    return feature;
+}
+function isFeature(value) {
+    return value !== null && typeof value === 'object' && results.has(value);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { createClient } from './client';
+export { SplitMode } from './types';
+export type { Client } from './client';
+export { FeatureError } from './errors';
+export type { FeatureErrorCode } from './errors';
+export { createThinkingDataAdapter } from './report/thinking-data-adapter';
+export type { Evaluation } from './evaluation';
+export type { Feature } from './feature';
+export type { ClientOptions, FeatureRequest, FetchOptions, AbortSignalLike, ExperimentInfo, JsonValue, JsonObject, ExposureAdapter, ExposureEvent, ExposureProperties, ExposureValue, ExposureSubmission, ThinkingDataAnalytics, ThinkingDataTrackEvent, } from './types';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createThinkingDataAdapter = exports.FeatureError = exports.SplitMode = exports.createClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "SplitMode", { enumerable: true, get: function () { return types_1.SplitMode; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "FeatureError", { enumerable: true, get: function () { return errors_1.FeatureError; } });
+var thinking_data_adapter_1 = require("./report/thinking-data-adapter");
+Object.defineProperty(exports, "createThinkingDataAdapter", { enumerable: true, get: function () { return thinking_data_adapter_1.createThinkingDataAdapter; } });

package/dist/report/event.d.ts

@@ -0,0 +1,3 @@
+import type { ExperimentInfo, ExposureEvent, ExposureProperties } from '../types';
+export declare function exposureSubject(info: ExperimentInfo, account: string | null, distinct: string | null): string;
+export declare function exposureEvent(accountId: string | null, distinctId: string | null, info: ExperimentInfo, custom?: ExposureProperties | null): ExposureEvent;

package/dist/report/event.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exposureSubject = exposureSubject;
+exports.exposureEvent = exposureEvent;
+const errors_1 = require("../errors");
+function exposureSubject(info, account, distinct) {
+    const bucket = info.bucketId;
+    if (bucket) {
+        const keys = Object.keys(bucket);
+        for (let i = 0; i < keys.length; i++) {
+            const value = bucket[keys[i]];
+            if (value !== null && value !== '')
+                return keys[i] + '=' + value;
+        }
+    }
+    if (account)
+        return '#account_id=' + account;
+    if (distinct)
+        return '#distinct_id=' + distinct;
+    throw new errors_1.FeatureError('accountId or distinctId is required for exposure', 'INVALID_REQUEST');
+}
+function copy(value, parents = []) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number' && isFinite(value))
+        return value;
+    if (!value || typeof value !== 'object' || parents.indexOf(value) >= 0)
+        throw new Error('Expected acyclic exposure properties');
+    if (value instanceof Date) {
+        if (!isFinite(value.getTime()))
+            throw new Error('Invalid exposure Date');
+        return new Date(value.getTime());
+    }
+    const path = parents.concat([value]);
+    if (Array.isArray(value))
+        return value.map(function (item) {
+            return copy(item, path);
+        });
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== null && prototype !== Object.prototype)
+        throw new Error('Expected exposure JSON objects or Dates');
+    const result = Object.create(null);
+    Object.keys(value).forEach(function (key) {
+        result[key] = copy(value[key], path);
+    });
+    return result;
+}
+function exposureEvent(accountId, distinctId, info, custom) {
+    const properties = Object.create(null);
+    if (custom !== undefined && custom !== null) {
+        if (typeof custom !== 'object' || Array.isArray(custom) || custom instanceof Date)
+            throw new errors_1.FeatureError('Exposure properties must be an object', 'INVALID_REQUEST');
+        try {
+            Object.keys(custom).forEach(function (key) {
+                if (key.charAt(0) !== '#')
+                    properties[key] = copy(custom[key]);
+            });
+        }
+        catch (error) {
+            throw new errors_1.FeatureError('Invalid exposure properties', 'INVALID_REQUEST', {
+                cause: error,
+            });
+        }
+    }
+    properties['#experiment_id'] = info.experimentId;
+    properties['#experiment_group_id'] = info.experimentGroupId;
+    properties['#is_control_group'] = info.isControlGroup;
+    properties['#rule_type'] = 'experiment';
+    const fields = {
+        '#feature_key': info.featureKey,
+        '#feature_version': info.featureVersion,
+        '#split_mode': info.splitMode,
+        '#assignment_source': info.assignmentSource,
+    };
+    Object.keys(fields).forEach(function (key) {
+        const value = fields[key];
+        if (value !== null && value !== undefined && value !== '')
+            properties[key] = value;
+    });
+    return {
+        accountId: accountId,
+        distinctId: distinctId,
+        event: 'te_experiment_exposure',
+        properties: properties,
+    };
+}