Initialize JavaScript (Node) SDK

const optimizely = require('@optimizely/optimizely-sdk');
const optimizelyClientInstance = optimizely.createInstance({
  sdkKey: '12345', // Provide the sdkKey of your desired environment here
});

const optimizely = require('@optimizely/optimizely-sdk');
const optimizelyClientInstance = optimizely.createInstance({
  sdkKey: '12345', // Provide the sdkKey of your desired environment here
});
optimizelyClientInstance.onReady().then(() => {
  // optimizelyClientInstance is ready to use, with datafile downloaded from the
  // Optimizely CDN
});

// Minimal client
const optimizely = require("@optimizely/optimizely-sdk");
const rp = require("request-promise");

// replace <Your_SDK_Key>
const DATAFILE_URL =
  "https://cdn.optimizely.com/datafiles/<Your_SDK_Key>.json";
const datafile = await rp({ uri: DATAFILE_URL, json: true });
console.log("Datafile:", datafile);
const optimizelyClient = optimizely.createInstance({
  datafile
});
// Use optimizelyClient to run experiments

const optimizely = require('@optimizely/optimizely-sdk');

const optimizelyClientInstance = optimizely.createInstance({
  sdkKey: '12345',
  datafileOptions: {
    autoUpdate: true,
    updateInterval: 600000, // 10 minutes in milliseconds
    urlTemplate: 'http://localhost:5000/datafiles/%s.json',
  },
});

const optimizely = require('@optimizely/optimizely-sdk');
let optimizelyClient = optimizely.createInstance({
  sdkKey: '12345',
});
optimizelyClient.onReady().then(() => {
  // optimizelyClientInstance is ready to use, with datafile downloaded from the Optimizely CDN
});

// Provide a timeout in milliseconds - promise will resolve if the datafile still is not available after the timeout
instance.onReady({ timeout: 5000 }).then(result => {
  // Returned Promise is fulfilled with a result object
  console.log(result.success); // true if the instance fetched a datafile and is now ready to use
  console.log(result.reason); // If success is false, reason contains an error message
})

const optimizely = require('@optimizely/optimizely-sdk');
const datafile = '{"version": "4", "rollouts": [], "typedAudiences": [], "anonymizeIP": false, "projectId": "12345", "variables": [], "featureFlags": [], "experiments": [], "audiences": [], "groups": [], "attributes": [], "botFiltering": false, "accountId": "12345", "events": [], "revision": "1"}'; 
const optimizelyClientInstance = optimizely.createInstance({
  sdkKey: '<Your_SDK_Key>',
  datafile,
});
// optimizelyClientInstance can be used immediately with the given datafile, but
// will download the latest datafile and update itself

const optimizelyInstance = optimizelySdk.createInstance({  
  sdkKey: '<YOUR_SDK_KEY>',  
  odpOptions: {  
    disabled: true,  
  },  
});

const optimizelyInstance = optimizelySdk.createInstance({  
  sdkKey: '<YOUR_SDK_KEY>',  
  odpOptions: {  
    // disabled: false,  
    eventApiTimeout: 1000,  
    eventBatchSize: 1,  
    eventFlushInterval: 0,  
    eventQueueSize: 1,  
    // eventRequestHandler: new BrowserRequestHandler(),  
    // eventManager: new OdpEventManager(),  
    segmentsApiTimeout: 1000,  
    segmentsCacheSize: 10,  
    segmentsCacheTimeout: 1000,  
    // segmentsCache: new ICache<string, string[]>(),  
    // segmentsRequestHandler: new BrowserRequestHandler(),  
    // segmentManager: new OdpSegmentManager(),

  },  
});

odpOptions: {  
  // ...
  eventManager: new OdpEventManager({  
    odpConfig, // new OdpConfig()  
    apiManager, // new OdpEventApiManager()  
    logger, // new LogHandler()  
    clientEngine: 'javascript-sdk',  
    clientVersion: '5.0.0',  
    batchSize: 10, 
    flushInterval: 2000,
  }),  
},

export interface IOdpEventApiManager {  
  sendEvents(apiKey: string, apiHost: string, events: OdpEvent[]): Promise<boolean>;  
}

odpOptions: {  
  // ...
  segmentManager: new OdpSegmentManager(  
    odpConfig, // new OdpConfig()  
    new BrowserLRUCache<string, string[]>({  
      maxSize: 2,  
      timeout: 4000,  
    }), // new ICache<string, string[]>()  
    segmentApiManager, // new IOdpSegmentApiManager()  
  ),  
},

export interface ICache<K, V> {
  lookup(key: K): V | null;
  save({ key, value }: { key: K; value: V }): void;
  reset(): void;
}

export class LRUCache<K, V> implements ICache<K, V> {
  private _map: Map<K, CacheElement<V>> = new Map();
  private _maxSize; // Defines maximum size of _map
  private _timeout; // Milliseconds each entry has before it becomes stale

  get map(): Map<K, CacheElement<V>> {
    return this._map;
  }

  get maxSize(): number {
    return this._maxSize;
  }

  get timeout(): number {
    return this._timeout;
  }

  constructor({ maxSize, timeout }: LRUCacheConfig) {
    const logger = getLogger();

    logger.debug(`Provisioning cache with maxSize of ${maxSize}`);
    logger.debug(`Provisioning cache with timeout of ${timeout}`);

    this._maxSize = maxSize;
    this._timeout = timeout;
  }

  public lookup(key: K): V | null {
    if (this._maxSize <= 0) {
      return null;
    }

    const element: CacheElement<V> | undefined = this._map.get(key);

    if (!element) return null;

    if (element.is_stale(this._timeout)) {
      this._map.delete(key);
      return null;
    }

    this._map.delete(key);
    this._map.set(key, element);

    return element.value;
  }

  public save({ key, value }: { key: K; value: V }): void {
    if (this._maxSize <= 0) return;

    const element: CacheElement<V> | undefined = this._map.get(key);
    if (element) this._map.delete(key);
    this._map.set(key, new CacheElement(value));

    if (this._map.size > this._maxSize) {
      const firstMapEntryKey = this._map.keys().next().value;
      this._map.delete(firstMapEntryKey);
    }
  }

  public reset(): void {
    if (this._maxSize <= 0) return;

    this._map.clear();
  }

  public peek(key: K): V | null {
    if (this._maxSize <= 0) return null;

    const element: CacheElement<V> | undefined = this._map.get(key);

    return element?.value ?? null;
  }
}

const optimizely = require('@optimizely/optimizely-sdk');

// fetch the datafile from an authenticated endpoint
const optimizelyClientInstance = optimizely.createInstance({
  sdkKey: '<YOUR_SDK_KEY>',
  datafileOptions: {
    datafileAccessToken: '<YOUR_DATAFILE_ACCESS_TOKEN>',
  },
});