@absmartly/javascript-sdk/types/context.d.ts

A/B Smartly Javascript SDK

import SDK, { EventLogger } from "./sdk";
import { ContextPublisher } from "./publisher";
import { ContextDataProvider } from "./provider";
import { ClientRequestOptions } from "./client";
type JSONPrimitive = string | number | boolean | null;
type JSONObject = {
    [key: string]: JSONValue;
};
type JSONArray = JSONValue[];
type JSONValue = JSONPrimitive | JSONObject | JSONArray;
type CustomFieldValueType = "text" | "string" | "number" | "json" | "boolean";
type CustomFieldValue = {
    name: string;
    value: string;
    type: CustomFieldValueType;
};
export type ExperimentData = {
    id: number;
    name: string;
    unitType: string | null;
    iteration: number;
    fullOnVariant: number;
    trafficSplit: number[];
    trafficSeedHi: number;
    trafficSeedLo: number;
    audience: string;
    audienceStrict: boolean;
    split: number[];
    seedHi: number;
    seedLo: number;
    variants: {
        config: null | string;
    }[];
    variables: Record<string, unknown>;
    variant: number;
    overridden: boolean;
    assigned: boolean;
    exposed: boolean;
    eligible: boolean;
    fullOn: boolean;
    custom: boolean;
    audienceMismatch: boolean;
    customFieldValues: CustomFieldValue[] | null;
};
export type Experiment = {
    data: ExperimentData;
    variables: Record<string, unknown>[];
};
export type Unit = {
    type: string;
    uid: string | null;
};
export type Exposure = {
    id: number;
    name: string;
    exposedAt: number;
    unit: string | null;
    variant: number;
    assigned: boolean;
    eligible: boolean;
    overridden: boolean;
    fullOn: boolean;
    custom: boolean;
    audienceMismatch: boolean;
};
export type Attribute = {
    name: string;
    value: unknown;
    setAt: number;
};
export type Units = {
    [key: string]: string | number;
};
export type Goal = {
    name: string;
    properties: Record<string, unknown> | null;
    achievedAt: number;
};
export type ContextParams = {
    units: Record<string, string | number>;
};
export type ContextOptions = {
    publisher?: ContextPublisher;
    dataProvider?: ContextDataProvider;
    eventLogger?: EventLogger;
    refreshPeriod: number;
    publishDelay: number;
};
export type ContextData = {
    experiments?: ExperimentData[];
};
export default class Context {
    private readonly _assigners;
    private readonly _attrs;
    private readonly _audienceMatcher;
    private readonly _cassignments;
    private readonly _dataProvider;
    private readonly _eventLogger;
    private readonly _opts;
    private readonly _publisher;
    private readonly _sdk;
    private readonly _units;
    private _assignments;
    private _data;
    private _exposures;
    private _failed;
    private _finalized;
    private _finalizing;
    private _goals;
    private _index;
    private _indexVariables;
    private _overrides;
    private _pending;
    private _hashes?;
    private _promise?;
    private _publishTimeout?;
    private _refreshInterval?;
    constructor(sdk: SDK, options: ContextOptions, params: ContextParams, promise: ContextData | Promise<ContextData>);
    isReady(): boolean;
    isFinalizing(): boolean;
    isFinalized(): boolean;
    isFailed(): boolean;
    ready(): Promise<unknown>;
    pending(): number;
    data(): ContextData;
    eventLogger(): EventLogger;
    publisher(): ContextPublisher;
    provider(): ContextDataProvider;
    publish(requestOptions?: ClientRequestOptions): Promise<void>;
    refresh(requestOptions?: ClientRequestOptions): Promise<void>;
    getUnit(unitType: string): string | number;
    unit(unitType: string, uid: string | number): void;
    getUnits(): Units;
    units(units: Record<string, number | string>): void;
    getAttribute(attrName: string): undefined;
    attribute(attrName: string, value: unknown): void;
    getAttributes(): Record<string, unknown>;
    attributes(attrs: Record<string, unknown>): void;
    peek(experimentName: string): number;
    treatment(experimentName: string): number;
    track(goalName: string, properties?: Record<string, unknown>): void;
    finalize(requestOptions?: ClientRequestOptions): true | Promise<void>;
    experiments(): string[] | undefined;
    variableValue(key: string, defaultValue: string): string;
    peekVariableValue(key: string, defaultValue: string): string;
    variableKeys(): Record<string, unknown[]>;
    override(experimentName: string, variant: number): void;
    overrides(experimentVariants: Record<string, number>): void;
    customAssignment(experimentName: string, variant: number): void;
    customAssignments(experimentVariants: Record<string, number>): void;
    private _checkNotFinalized;
    private _checkReady;
    private _assign;
    private _peek;
    private _treatment;
    private _queueExposure;
    private _customFieldKeys;
    customFieldKeys(): string[];
    private _customFieldValue;
    customFieldValue(experimentName: string, key: string): JSONValue;
    private _customFieldValueType;
    customFieldValueType(experimentName: string, key: string): CustomFieldValueType | null;
    private _variableValue;
    private _peekVariable;
    private _validateGoal;
    private _track;
    private _setTimeout;
    private _flush;
    private _refresh;
    private _logEvent;
    private _logError;
    private _unitHash;
    private _init;
    private _finalize;
}
export {};
//# sourceMappingURL=context.d.ts.map