@featurevisor/sdk 1.35.2 → 2.0.0

package/dist/instance.d.ts

@@ -1,99 +1,67 @@
-import { Context, DatafileContent, Feature, FeatureKey, InitialFeatures, StickyFeatures, VariableType, VariableValue, VariationValue, VariableKey } from "@featurevisor/types";
+import type { Context, Feature, FeatureKey, StickyFeatures, EvaluatedFeatures, VariableValue, VariationValue, VariableKey, DatafileContent } from "@featurevisor/types";
 import { Logger, LogLevel } from "./logger";
-import { Emitter } from "./emitter";
-import { ConfigureBucketKey, ConfigureBucketValue } from "./bucket";
+import { Hook } from "./hooks";
+import { EventCallback, EventName } from "./emitter";
 import { Evaluation } from "./evaluate";
-export type ReadyCallback = () => void;
-export type ActivationCallback = (featureName: string, variation: VariationValue, context: Context, captureContext: Context) => void;
-export interface Statuses {
-    ready: boolean;
-    refreshInProgress: boolean;
+import { FeaturevisorChildInstance } from "./child";
+export interface OverrideOptions {
+    sticky?: StickyFeatures;
+    defaultVariationValue?: VariationValue;
+    defaultVariableValue?: VariableValue;
 }
-export type InterceptContext = (context: Context) => Context;
 export interface InstanceOptions {
-    bucketKeySeparator?: string;
-    configureBucketKey?: ConfigureBucketKey;
-    configureBucketValue?: ConfigureBucketValue;
     datafile?: DatafileContent | string;
-    datafileUrl?: string;
-    handleDatafileFetch?: (datafileUrl: string) => Promise<DatafileContent>;
-    initialFeatures?: InitialFeatures;
-    interceptContext?: InterceptContext;
+    context?: Context;
+    logLevel?: LogLevel;
     logger?: Logger;
-    onActivation?: ActivationCallback;
-    onReady?: ReadyCallback;
-    onRefresh?: () => void;
-    onUpdate?: () => void;
-    refreshInterval?: number;
-    stickyFeatures?: StickyFeatures;
+    sticky?: StickyFeatures;
+    hooks?: Hook[];
 }
-export type DatafileFetchHandler = (datafileUrl: string) => Promise<DatafileContent>;
-type FieldType = string | VariableType;
-type ValueType = VariableValue;
-export declare function getValueByType(value: ValueType, fieldType: FieldType): ValueType;
 export declare class FeaturevisorInstance {
-    private bucketKeySeparator;
-    private configureBucketKey?;
-    private configureBucketValue?;
-    private datafileUrl?;
-    private handleDatafileFetch?;
-    private initialFeatures?;
-    private interceptContext?;
+    private context;
     private logger;
-    private refreshInterval?;
-    private stickyFeatures?;
+    private sticky?;
     private datafileReader;
+    private hooksManager;
     private emitter;
-    private statuses;
-    private intervalId?;
-    on: Emitter["addListener"];
-    addListener: Emitter["addListener"];
-    off: Emitter["removeListener"];
-    removeListener: Emitter["removeListener"];
-    removeAllListeners: Emitter["removeAllListeners"];
     constructor(options: InstanceOptions);
-    setLogLevels(levels: LogLevel[]): void;
-    onReady(): Promise<FeaturevisorInstance>;
+    setLogLevel(level: LogLevel): void;
     setDatafile(datafile: DatafileContent | string): void;
-    setStickyFeatures(stickyFeatures: StickyFeatures | undefined): void;
+    setSticky(sticky: StickyFeatures, replace?: boolean): void;
     getRevision(): string;
-    getFeature(featureKey: string | Feature): Feature | undefined;
+    getFeature(featureKey: string): Feature | undefined;
+    addHook(hook: Hook): () => void;
+    on(eventName: EventName, callback: EventCallback): () => void;
+    close(): void;
     /**
-     * Statuses
+     * Context
      */
-    isReady(): boolean;
-    /**
-     * Refresh
-     */
-    refresh(): void;
-    startRefreshing(): void;
-    stopRefreshing(): void;
+    setContext(context: Context, replace?: boolean): void;
+    getContext(context?: Context): Context;
+    spawn(context?: Context, options?: OverrideOptions): FeaturevisorChildInstance;
     /**
      * Flag
      */
-    evaluateFlag(featureKey: FeatureKey | Feature, context?: Context): Evaluation;
-    isEnabled(featureKey: FeatureKey | Feature, context?: Context): boolean;
+    private getEvaluationDependencies;
+    evaluateFlag(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): Evaluation;
+    isEnabled(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): boolean;
     /**
      * Variation
      */
-    evaluateVariation(featureKey: FeatureKey | Feature, context?: Context): Evaluation;
-    getVariation(featureKey: FeatureKey | Feature, context?: Context): VariationValue | undefined;
-    /**
-     * Activate
-     */
-    activate(featureKey: FeatureKey, context?: Context): VariationValue | undefined;
+    evaluateVariation(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): Evaluation;
+    getVariation(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): VariationValue | null;
     /**
      * Variable
      */
-    evaluateVariable(featureKey: FeatureKey | Feature, variableKey: VariableKey, context?: Context): Evaluation;
-    getVariable(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): VariableValue | undefined;
-    getVariableBoolean(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): boolean | undefined;
-    getVariableString(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): string | undefined;
-    getVariableInteger(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): number | undefined;
-    getVariableDouble(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): number | undefined;
-    getVariableArray(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): string[] | undefined;
-    getVariableObject<T>(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): T | undefined;
-    getVariableJSON<T>(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): T | undefined;
+    evaluateVariable(featureKey: FeatureKey, variableKey: VariableKey, context?: Context, options?: OverrideOptions): Evaluation;
+    getVariable(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): VariableValue | null;
+    getVariableBoolean(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): boolean | null;
+    getVariableString(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string | null;
+    getVariableInteger(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableDouble(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableArray(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string[] | null;
+    getVariableObject<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getVariableJSON<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getAllEvaluations(context?: Context, featureKeys?: string[], options?: OverrideOptions): EvaluatedFeatures;
 }
 export declare function createInstance(options: InstanceOptions): FeaturevisorInstance;
-export {};

package/dist/logger.d.ts

@@ -1,21 +1,22 @@
-export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogLevel = "fatal" | "error" | "warn" | "info" | "debug";
 export type LogMessage = string;
 export interface LogDetails {
     [key: string]: any;
 }
 export type LogHandler = (level: LogLevel, message: LogMessage, details?: LogDetails) => void;
 export interface CreateLoggerOptions {
-    levels?: LogLevel[];
+    level?: LogLevel;
     handler?: LogHandler;
 }
 export declare const loggerPrefix = "[Featurevisor]";
-export declare const defaultLogLevels: LogLevel[];
 export declare const defaultLogHandler: LogHandler;
 export declare class Logger {
-    private levels;
+    static allLevels: LogLevel[];
+    static defaultLevel: LogLevel;
+    private level;
     private handle;
     constructor(options: CreateLoggerOptions);
-    setLevels(levels: LogLevel[]): void;
+    setLevel(level: LogLevel): void;
     log(level: LogLevel, message: LogMessage, details?: LogDetails): void;
     debug(message: LogMessage, details?: LogDetails): void;
     info(message: LogMessage, details?: LogDetails): void;

package/dist/murmurhash.d.ts

@@ -0,0 +1 @@
+export declare function MurmurHashV3(key: any, seed: any): number;

package/jest.config.js

@@ -1,4 +1,6 @@
 module.exports = {
   preset: "ts-jest",
   bail: true,
+  collectCoverageFrom: ["src/**/*.ts"],
+  coveragePathIgnorePatterns: ["src/index.ts", "src/murmurhash.ts", "src/compareVersions.ts"],
 };

package/lib/bucketer.d.ts

@@ -0,0 +1,11 @@
+import type { BucketKey, Context, FeatureKey, BucketBy } from "@featurevisor/types";
+import { Logger } from "./logger";
+export declare const MAX_BUCKETED_NUMBER = 100000;
+export declare function getBucketedNumber(bucketKey: string): number;
+export interface GetBucketKeyOptions {
+    featureKey: FeatureKey;
+    bucketBy: BucketBy;
+    context: Context;
+    logger: Logger;
+}
+export declare function getBucketKey(options: GetBucketKeyOptions): BucketKey;

package/lib/child.d.ts

@@ -0,0 +1,26 @@
+import type { Context, StickyFeatures, FeatureKey, VariationValue, VariableValue, EvaluatedFeatures } from "@featurevisor/types";
+import { EventName, EventCallback } from "./emitter";
+import type { OverrideOptions } from "./instance";
+export declare class FeaturevisorChildInstance {
+    private parent;
+    private context;
+    private sticky;
+    private emitter;
+    constructor(options: any);
+    on(eventName: EventName, callback: EventCallback): () => void;
+    close(): void;
+    setContext(context: Context, replace?: boolean): void;
+    getContext(context?: Context): Context;
+    setSticky(sticky: StickyFeatures, replace?: boolean): void;
+    isEnabled(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): boolean;
+    getVariation(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): VariationValue | null;
+    getVariable(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): VariableValue | null;
+    getVariableBoolean(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): boolean | null;
+    getVariableString(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string | null;
+    getVariableInteger(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableDouble(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableArray(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string[] | null;
+    getVariableObject<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getVariableJSON<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getAllEvaluations(context?: Context, featureKeys?: string[], options?: OverrideOptions): EvaluatedFeatures;
+}

package/lib/compareVersions.d.ts

@@ -0,0 +1,4 @@
+export declare const semver: RegExp;
+export declare const validateAndParse: (version: string) => RegExpMatchArray;
+export declare const compareSegments: (a: string | string[] | RegExpMatchArray, b: string | string[] | RegExpMatchArray) => 1 | 0 | -1;
+export declare const compareVersions: (v1: string, v2: string) => 1 | 0 | -1;

package/lib/conditions.d.ts

@@ -1,4 +1,4 @@
-import { Context, Condition, PlainCondition } from "@featurevisor/types";
-import { Logger } from "./logger";
-export declare function conditionIsMatched(condition: PlainCondition, context: Context): boolean;
-export declare function allConditionsAreMatched(conditions: Condition[] | Condition, context: Context, logger: Logger): boolean;
+import type { Context, PlainCondition, AttributeValue } from "@featurevisor/types";
+import { GetRegex } from "./datafileReader";
+export declare function getValueFromContext(obj: any, path: any): AttributeValue;
+export declare function conditionIsMatched(condition: PlainCondition, context: Context, getRegex: GetRegex): boolean;

package/lib/datafileReader.d.ts

@@ -1,16 +1,36 @@
-import { Feature, Segment, DatafileContentV1, DatafileContentV2, Attribute, AttributeKey, SegmentKey, FeatureKey } from "@featurevisor/types";
-export declare function parseJsonConditionsIfStringified<T>(record: T, key: string): T;
+import type { Feature, Segment, DatafileContent, SegmentKey, FeatureKey, Context, Traffic, Allocation, GroupSegment, Condition, Force } from "@featurevisor/types";
+import { Logger } from "./logger";
+export type GetRegex = (regexString: string, regexFlags: string) => RegExp;
+export interface DatafileReaderOptions {
+    datafile: DatafileContent;
+    logger: Logger;
+}
+export interface ForceResult {
+    force?: Force;
+    forceIndex?: number;
+}
 export declare class DatafileReader {
     private schemaVersion;
     private revision;
-    private attributes;
     private segments;
     private features;
-    constructor(datafileJson: DatafileContentV1 | DatafileContentV2);
+    private logger;
+    private regexCache;
+    constructor(options: DatafileReaderOptions);
     getRevision(): string;
     getSchemaVersion(): string;
-    getAllAttributes(): Attribute[];
-    getAttribute(attributeKey: AttributeKey): Attribute | undefined;
     getSegment(segmentKey: SegmentKey): Segment | undefined;
+    getFeatureKeys(): string[];
     getFeature(featureKey: FeatureKey): Feature | undefined;
+    getVariableKeys(featureKey: FeatureKey): string[];
+    hasVariations(featureKey: FeatureKey): boolean;
+    getRegex(regexString: string, regexFlags?: string): RegExp;
+    allConditionsAreMatched(conditions: Condition[] | Condition, context: Context): boolean;
+    segmentIsMatched(segment: Segment, context: Context): boolean;
+    allSegmentsAreMatched(groupSegments: GroupSegment | GroupSegment[] | "*", context: Context): boolean;
+    getMatchedTraffic(traffic: Traffic[], context: Context): Traffic | undefined;
+    getMatchedAllocation(traffic: Traffic, bucketValue: number): Allocation | undefined;
+    getMatchedForce(featureKey: FeatureKey | Feature, context: Context): ForceResult;
+    parseConditionsIfStringified(conditions: Condition | Condition[]): Condition | Condition[];
+    parseSegmentsIfStringified(segments: GroupSegment | GroupSegment[]): GroupSegment | GroupSegment[];
 }

package/lib/emitter.d.ts

@@ -1,12 +1,11 @@
-export type EventName = "ready" | "refresh" | "update" | "activation";
-export interface Listeners {
-    [key: string]: Function[];
-}
+export type EventName = "datafile_set" | "context_set" | "sticky_set";
+export type EventDetails = Record<string, unknown>;
+export type EventCallback = (details: EventDetails) => void;
+export type Listeners = Record<EventName, EventCallback[]> | {};
 export declare class Emitter {
-    private _listeners;
+    listeners: Listeners;
     constructor();
-    addListener(eventName: EventName, fn: Function): void;
-    removeListener(eventName: EventName, fn: Function): void;
-    removeAllListeners(eventName?: EventName): void;
-    emit(eventName: EventName, ...args: any[]): void;
+    on(eventName: EventName, callback: EventCallback): () => void;
+    trigger(eventName: EventName, details?: EventDetails): void;
+    clearAll(): void;
 }

package/lib/evaluate.d.ts

@@ -1,26 +1,28 @@
-import { Feature, FeatureKey, Context, BucketKey, BucketValue, RuleKey, Traffic, Force, Required, OverrideFeature, Variation, VariationValue, VariableKey, VariableValue, VariableSchema, StickyFeatures, InitialFeatures } from "@featurevisor/types";
+import type { FeatureKey, Context, BucketKey, BucketValue, RuleKey, Traffic, Force, Required, Variation, VariationValue, VariableKey, VariableValue, VariableSchema, EvaluatedFeature, StickyFeatures } from "@featurevisor/types";
 import { Logger } from "./logger";
+import { HooksManager } from "./hooks";
 import { DatafileReader } from "./datafileReader";
-import { ConfigureBucketKey, ConfigureBucketValue } from "./bucket";
-import type { Statuses, InterceptContext } from "./instance";
 export declare enum EvaluationReason {
-    NOT_FOUND = "not_found",
-    NO_VARIATIONS = "no_variations",
-    NO_MATCH = "no_match",
-    DISABLED = "disabled",
-    REQUIRED = "required",
-    OUT_OF_RANGE = "out_of_range",
-    FORCED = "forced",
-    INITIAL = "initial",
-    STICKY = "sticky",
-    RULE = "rule",
-    ALLOCATED = "allocated",
-    DEFAULTED = "defaulted",
-    OVERRIDE = "override",
+    FEATURE_NOT_FOUND = "feature_not_found",// feature is not found in datafile
+    DISABLED = "disabled",// feature is disabled
+    REQUIRED = "required",// required features are not enabled
+    OUT_OF_RANGE = "out_of_range",// out of range when mutually exclusive experiments are involved via Groups
+    NO_VARIATIONS = "no_variations",// feature has no variations
+    VARIATION_DISABLED = "variation_disabled",// feature is disabled, and variation's disabledVariationValue is used
+    VARIABLE_NOT_FOUND = "variable_not_found",// variable's schema is not defined in the feature
+    VARIABLE_DEFAULT = "variable_default",// default variable value used
+    VARIABLE_DISABLED = "variable_disabled",// feature is disabled, and variable's disabledValue is used
+    VARIABLE_OVERRIDE = "variable_override",// variable overridden from inside a variation
+    NO_MATCH = "no_match",// no rules matched
+    FORCED = "forced",// against a forced rule
+    STICKY = "sticky",// against a sticky feature
+    RULE = "rule",// against a regular rule
+    ALLOCATED = "allocated",// regular allocation based on bucketing
     ERROR = "error"
 }
 type EvaluationType = "flag" | "variation" | "variable";
 export interface Evaluation {
+    type: EvaluationType;
     featureKey: FeatureKey;
     reason: EvaluationReason;
     bucketKey?: BucketKey;
@@ -32,28 +34,28 @@ export interface Evaluation {
     forceIndex?: number;
     force?: Force;
     required?: Required[];
-    sticky?: OverrideFeature;
-    initial?: OverrideFeature;
+    sticky?: EvaluatedFeature;
     variation?: Variation;
     variationValue?: VariationValue;
     variableKey?: VariableKey;
     variableValue?: VariableValue;
     variableSchema?: VariableSchema;
 }
-export interface EvaluateOptions {
-    type: EvaluationType;
-    featureKey: FeatureKey | Feature;
-    variableKey?: VariableKey;
+export interface EvaluateDependencies {
     context: Context;
     logger: Logger;
+    hooksManager: HooksManager;
     datafileReader: DatafileReader;
-    statuses?: Statuses;
-    interceptContext?: InterceptContext;
-    stickyFeatures?: StickyFeatures;
-    initialFeatures?: InitialFeatures;
-    bucketKeySeparator?: string;
-    configureBucketKey?: ConfigureBucketKey;
-    configureBucketValue?: ConfigureBucketValue;
+    sticky?: StickyFeatures;
+    defaultVariationValue?: VariationValue;
+    defaultVariableValue?: VariableValue;
+}
+export interface EvaluateParams {
+    type: EvaluationType;
+    featureKey: FeatureKey;
+    variableKey?: VariableKey;
 }
+export type EvaluateOptions = EvaluateParams & EvaluateDependencies;
+export declare function evaluateWithHooks(opts: EvaluateOptions): Evaluation;
 export declare function evaluate(options: EvaluateOptions): Evaluation;
 export {};

package/lib/events.d.ts

@@ -0,0 +1,5 @@
+import type { StickyFeatures } from "@featurevisor/types";
+import type { EventDetails } from "./emitter";
+import type { DatafileReader } from "./datafileReader";
+export declare function getParamsForStickySetEvent(previousStickyFeatures: StickyFeatures, newStickyFeatures: StickyFeatures, replace: any): EventDetails;
+export declare function getParamsForDatafileSetEvent(previousDatafileReader: DatafileReader, newDatafileReader: DatafileReader): EventDetails;

package/lib/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { VariableType, VariableValue } from "@featurevisor/types";
+type FieldType = string | VariableType;
+type ValueType = VariableValue;
+export declare function getValueByType(value: ValueType, fieldType: FieldType): ValueType;
+export {};

package/lib/hooks.d.ts

@@ -0,0 +1,45 @@
+import type { BucketBy, BucketKey, BucketValue, Context, FeatureKey } from "@featurevisor/types";
+import type { EvaluateOptions, Evaluation } from "./evaluate";
+import type { Logger } from "./logger";
+/**
+ * bucketKey
+ */
+export interface ConfigureBucketKeyOptions {
+    featureKey: FeatureKey;
+    context: Context;
+    bucketBy: BucketBy;
+    bucketKey: string;
+}
+export type ConfigureBucketKey = (options: ConfigureBucketKeyOptions) => BucketKey;
+/**
+ * bucketValue
+ */
+export interface ConfigureBucketValueOptions {
+    featureKey: FeatureKey;
+    bucketKey: string;
+    context: Context;
+    bucketValue: number;
+}
+export type ConfigureBucketValue = (options: ConfigureBucketValueOptions) => BucketValue;
+/**
+ * Hooks
+ */
+export interface Hook {
+    name: string;
+    before?: (options: EvaluateOptions) => EvaluateOptions;
+    bucketKey?: ConfigureBucketKey;
+    bucketValue?: ConfigureBucketValue;
+    after?: (evaluation: Evaluation, options: EvaluateOptions) => Evaluation;
+}
+export interface HooksManagerOptions {
+    hooks?: Hook[];
+    logger: Logger;
+}
+export declare class HooksManager {
+    private hooks;
+    private logger;
+    constructor(options: HooksManagerOptions);
+    add(hook: Hook): (() => void) | undefined;
+    remove(name: string): void;
+    getAll(): Hook[];
+}

package/lib/index.d.ts

@@ -1,6 +1,7 @@
-export * from "./bucket";
+export * from "./bucketer";
 export * from "./instance";
 export * from "./logger";
 export * from "./conditions";
-export * from "./emitter";
 export * from "./evaluate";
+export * from "./datafileReader";
+export * from "./child";

package/lib/instance.d.ts

@@ -1,99 +1,67 @@
-import { Context, DatafileContent, Feature, FeatureKey, InitialFeatures, StickyFeatures, VariableType, VariableValue, VariationValue, VariableKey } from "@featurevisor/types";
+import type { Context, Feature, FeatureKey, StickyFeatures, EvaluatedFeatures, VariableValue, VariationValue, VariableKey, DatafileContent } from "@featurevisor/types";
 import { Logger, LogLevel } from "./logger";
-import { Emitter } from "./emitter";
-import { ConfigureBucketKey, ConfigureBucketValue } from "./bucket";
+import { Hook } from "./hooks";
+import { EventCallback, EventName } from "./emitter";
 import { Evaluation } from "./evaluate";
-export type ReadyCallback = () => void;
-export type ActivationCallback = (featureName: string, variation: VariationValue, context: Context, captureContext: Context) => void;
-export interface Statuses {
-    ready: boolean;
-    refreshInProgress: boolean;
+import { FeaturevisorChildInstance } from "./child";
+export interface OverrideOptions {
+    sticky?: StickyFeatures;
+    defaultVariationValue?: VariationValue;
+    defaultVariableValue?: VariableValue;
 }
-export type InterceptContext = (context: Context) => Context;
 export interface InstanceOptions {
-    bucketKeySeparator?: string;
-    configureBucketKey?: ConfigureBucketKey;
-    configureBucketValue?: ConfigureBucketValue;
     datafile?: DatafileContent | string;
-    datafileUrl?: string;
-    handleDatafileFetch?: (datafileUrl: string) => Promise<DatafileContent>;
-    initialFeatures?: InitialFeatures;
-    interceptContext?: InterceptContext;
+    context?: Context;
+    logLevel?: LogLevel;
     logger?: Logger;
-    onActivation?: ActivationCallback;
-    onReady?: ReadyCallback;
-    onRefresh?: () => void;
-    onUpdate?: () => void;
-    refreshInterval?: number;
-    stickyFeatures?: StickyFeatures;
+    sticky?: StickyFeatures;
+    hooks?: Hook[];
 }
-export type DatafileFetchHandler = (datafileUrl: string) => Promise<DatafileContent>;
-type FieldType = string | VariableType;
-type ValueType = VariableValue;
-export declare function getValueByType(value: ValueType, fieldType: FieldType): ValueType;
 export declare class FeaturevisorInstance {
-    private bucketKeySeparator;
-    private configureBucketKey?;
-    private configureBucketValue?;
-    private datafileUrl?;
-    private handleDatafileFetch?;
-    private initialFeatures?;
-    private interceptContext?;
+    private context;
     private logger;
-    private refreshInterval?;
-    private stickyFeatures?;
+    private sticky?;
     private datafileReader;
+    private hooksManager;
     private emitter;
-    private statuses;
-    private intervalId?;
-    on: Emitter["addListener"];
-    addListener: Emitter["addListener"];
-    off: Emitter["removeListener"];
-    removeListener: Emitter["removeListener"];
-    removeAllListeners: Emitter["removeAllListeners"];
     constructor(options: InstanceOptions);
-    setLogLevels(levels: LogLevel[]): void;
-    onReady(): Promise<FeaturevisorInstance>;
+    setLogLevel(level: LogLevel): void;
     setDatafile(datafile: DatafileContent | string): void;
-    setStickyFeatures(stickyFeatures: StickyFeatures | undefined): void;
+    setSticky(sticky: StickyFeatures, replace?: boolean): void;
     getRevision(): string;
-    getFeature(featureKey: string | Feature): Feature | undefined;
+    getFeature(featureKey: string): Feature | undefined;
+    addHook(hook: Hook): () => void;
+    on(eventName: EventName, callback: EventCallback): () => void;
+    close(): void;
     /**
-     * Statuses
+     * Context
      */
-    isReady(): boolean;
-    /**
-     * Refresh
-     */
-    refresh(): void;
-    startRefreshing(): void;
-    stopRefreshing(): void;
+    setContext(context: Context, replace?: boolean): void;
+    getContext(context?: Context): Context;
+    spawn(context?: Context, options?: OverrideOptions): FeaturevisorChildInstance;
     /**
      * Flag
      */
-    evaluateFlag(featureKey: FeatureKey | Feature, context?: Context): Evaluation;
-    isEnabled(featureKey: FeatureKey | Feature, context?: Context): boolean;
+    private getEvaluationDependencies;
+    evaluateFlag(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): Evaluation;
+    isEnabled(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): boolean;
     /**
      * Variation
      */
-    evaluateVariation(featureKey: FeatureKey | Feature, context?: Context): Evaluation;
-    getVariation(featureKey: FeatureKey | Feature, context?: Context): VariationValue | undefined;
-    /**
-     * Activate
-     */
-    activate(featureKey: FeatureKey, context?: Context): VariationValue | undefined;
+    evaluateVariation(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): Evaluation;
+    getVariation(featureKey: FeatureKey, context?: Context, options?: OverrideOptions): VariationValue | null;
     /**
      * Variable
      */
-    evaluateVariable(featureKey: FeatureKey | Feature, variableKey: VariableKey, context?: Context): Evaluation;
-    getVariable(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): VariableValue | undefined;
-    getVariableBoolean(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): boolean | undefined;
-    getVariableString(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): string | undefined;
-    getVariableInteger(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): number | undefined;
-    getVariableDouble(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): number | undefined;
-    getVariableArray(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): string[] | undefined;
-    getVariableObject<T>(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): T | undefined;
-    getVariableJSON<T>(featureKey: FeatureKey | Feature, variableKey: string, context?: Context): T | undefined;
+    evaluateVariable(featureKey: FeatureKey, variableKey: VariableKey, context?: Context, options?: OverrideOptions): Evaluation;
+    getVariable(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): VariableValue | null;
+    getVariableBoolean(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): boolean | null;
+    getVariableString(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string | null;
+    getVariableInteger(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableDouble(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): number | null;
+    getVariableArray(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): string[] | null;
+    getVariableObject<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getVariableJSON<T>(featureKey: FeatureKey, variableKey: string, context?: Context, options?: OverrideOptions): T | null;
+    getAllEvaluations(context?: Context, featureKeys?: string[], options?: OverrideOptions): EvaluatedFeatures;
 }
 export declare function createInstance(options: InstanceOptions): FeaturevisorInstance;
-export {};

package/lib/logger.d.ts

@@ -1,21 +1,22 @@
-export type LogLevel = "debug" | "info" | "warn" | "error";
+export type LogLevel = "fatal" | "error" | "warn" | "info" | "debug";
 export type LogMessage = string;
 export interface LogDetails {
     [key: string]: any;
 }
 export type LogHandler = (level: LogLevel, message: LogMessage, details?: LogDetails) => void;
 export interface CreateLoggerOptions {
-    levels?: LogLevel[];
+    level?: LogLevel;
     handler?: LogHandler;
 }
 export declare const loggerPrefix = "[Featurevisor]";
-export declare const defaultLogLevels: LogLevel[];
 export declare const defaultLogHandler: LogHandler;
 export declare class Logger {
-    private levels;
+    static allLevels: LogLevel[];
+    static defaultLevel: LogLevel;
+    private level;
     private handle;
     constructor(options: CreateLoggerOptions);
-    setLevels(levels: LogLevel[]): void;
+    setLevel(level: LogLevel): void;
     log(level: LogLevel, message: LogMessage, details?: LogDetails): void;
     debug(message: LogMessage, details?: LogDetails): void;
     info(message: LogMessage, details?: LogDetails): void;

package/lib/murmurhash.d.ts

@@ -0,0 +1 @@
+export declare function MurmurHashV3(key: any, seed: any): number;