Browser SDK

<!-- Choose the preferred script tag, you don't need both -->

<!-- Regular build, smaller footprint -->
<script src="//cdn.split.io/sdk/split-browser-0.1.0.min.js"></script>

<!-- Full build, bigger footprint but all modules are exposed and usable -->
<script src="//cdn.split.io/sdk/split-browser-0.1.0.full.min.js"></script>

npm install --save @splitsoftware/splitio-browserjs@0.1.0

// Instantiate the SDK. CDN will expose a splitio object globally with a reference to
// the SplitFactory (as well as any extra modules) 

var factory = splitio.SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    // key represents your internal user id, or the account id that 
    // the user belongs to. 
    // This coudld also be a cookie you generate for anonymous users
    key: 'key'
  }
});

// And get the client instance you'll use
var client = factory.client();

var SplitFactory = require('@splitsoftware/splitio-browserjs').SplitFactory;

// Instantiate the SDK
var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    // key represents your internal user id, or the account id that 
    // the user belongs to. 
    // This coudld also be a cookie you generate for anonymous users
    key: 'key'
  }
});

// And get the client instance you'll use
var client = factory.client();

import { SplitFactory } from '@splitsoftware/splitio-browserjs';

// Instantiate the SDK
const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    // key represents your internal user id, or the account id that 
    // the user belongs to. 
    // This coudld also be a cookie you generate for anonymous users
    key: 'key'
  }
});

// And get the client instance you'll use
const client: SplitIO.IClient = factory.client();

client.on(client.Event.SDK_READY, function() {
  var treatment = client.getTreatment("SPLIT_NAME");

  if (treatment == "on") {
      // insert code here to show on treatment
  } else if (treatment == "off") {
      // insert code here to show off treatment
  } else {
      // insert your control treatment code here
  }
});

client.on(client.Event.SDK_READY, function() {
  const treatment: SplitIO.Treatment = client.getTreatment("SPLIT_NAME");

  if (treatment == "on") {
      // insert code here to show on treatment
  } else if (treatment == "off") {
      // insert code here to show off treatment
  } else {
      // insert your control treatment code here
  }
});

// You can just destroy and remove the variable reference and move on:
user_client.destroy();
user_client = null;

// destroy() returns a promise, so if you want to, for example,
// navigate to another page without loosing impressions, you 
// can do that once the promise resolves.
user_client.destroy().then(function() {
     user_client = null;

  document.location.replace('another_page');
});

var splitNames = ['SPLIT_NAME_1', 'SPLIT_NAME_2'];

var treatments = client.getTreatments(splitNames);

// treatments will have the following form: 
// {
//   SPLIT_NAME_1: 'on',
//   SPLIT_NAME_2: 'visa'
// }

const splitNames = ['SPLIT_NAME_1', 'SPLIT_NAME_2'];

const treatments: SplitIO.Treatments = client.getTreatments(splitNames);

// treatments will have the following form: 
// {
//   SPLIT_NAME_1: 'on',
//   SPLIT_NAME_2: 'visa'
// }

var attributes = {
  // date attributes are handled as `millis since epoch`
  registered_date: new Date('YYYY-MM-DDTHH:mm:ss.sssZ').getTime(),
  // this string will be compared against a list called `plan_type`
  plan_type: 'growth',
  // this number will be compared agains a const value called `deal_size`
  deal_size: 10000,
  // this boolean will be compared against a const value called `paying_customer`
  paying_customer: true,
  // this array will be compared against a set called `permissions`
  permissions: ["read", "write"]
};

var treatment = client.getTreatment('SPLIT_NAME', attributes);

if (treatment === 'on') {
  // insert on code here
} else if (treatment === 'off') {
  // insert off code here
} else {
  // insert control code here
}

const attributes: SplitIO.Attributes = {
  // date attributes are handled as `millis since epoch`
  registered_date: new Date('YYYY-MM-DDTHH:mm:ss.sssZ').getTime(),
  // this string will be compared against a list called `plan_type`
  plan_type: 'growth',
  // this number will be compared agains a const value called `deal_size`
  deal_size: 10000,
  // this array will be compared against a set called `permissions`
  permissions: ['read', 'write']
};

const treatment: SplitIO.Treatment = client.getTreatment('SPLIT_NAME', attributes);

if (treatment === 'on') {
  // insert on code here
} else if (treatment === 'off') {
  // insert off code here
} else {
  // insert control code here
}

var TreatmentResult = {
   String treatment;
   String config; // or null if there is no config for the treatment
}

type TreatmentResult = {
    treatment: string,
    config: string | null
  };

var TreatmentResult = client.getTreatmentWithConfig('SPLIT_NAME', attributes);
var configs = JSON.parse(TreatmentResult.config);
var treatment = TreatmentResult.treatment;

if (treatment === 'on') {
  // insert on code here and use configs here as necessary
} else if (treatment === 'off') {
  // insert off code here and use configs here as necessary
} else {
  // insert control code here
}

const TreatmentResult: SplitIO.TreatmentWithConfig = client.getTreatmentWithConfig('SPLIT_NAME', attributes);
const configs = JSON.parse(TreatmentResult.config);
const treatment = TreatmentResult.treatment;

if (treatment === 'on') {
  // insert on code here and use configs here as necessary
} else if (treatment === 'off') {
  // insert off code here and use configs here as necessary
} else {
  // insert control code here
}

var splitNames = ['SPLIT_NAME_1', 'SPLIT_NAME_2'];

var TreatmentResults = client.getTreatmentsWithConfig(splitNames);

// TreatmentResults will have the following form: 
// {
//   SPLIT_NAME_1: {treatment: 'on',
//                  config: "{ 'color' : 'red'}}",
//   SPLIT_NAME_2: {treatment: 'v2',
//                  config: "{ 'copy' : 'better copy'}}",
// }

const splitNames = ['SPLIT_NAME_1', 'SPLIT_NAME_2'];

const TreatmentResults: SplitIO.TreatmentsWithConfig = client.getTreatmentsWithConfig(splitNames);

// TreatmentResults will have the following form: 
// {
//   SPLIT_NAME_1: {treatment: 'on',
//                  config: "{ 'color' : 'red'}}",
//   SPLIT_NAME_2: {treatment: 'v2',
//                  config: "{ 'copy' : 'better copy'}}",
// }

// The expected parameters are:
var queued = client.track('TRAFFIC_TYPE', 'EVENT_TYPE', eventValue, { properties });

// Example with both a value and properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('user', 'page_load_time', 83.334, properties);

// Example with only properties
var properties = {package : "premium", admin : true, discount : 50};
var queued = client.track('user', 'page_load_time', null, properties);

// The expected parameters are:
const queued: boolean = client.track('TRAFFIC_TYPE', 'EVENT_TYPE', eventValue, , { properties });

// Example with both a value and properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('user', 'page_load_time', 83.334, properties);

// Example with only properties
const properties = {package : "premium", admin : true, discount : 50};
const queued = client.track('user', 'page_load_time', null, properties);

var sdk = SplitFactory({
  startup: {
    readyTimeout:                 10, // 10 sec
    eventsFirstPushWindow:        10  // 10 sec
  },
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'YOUR_KEY'
  },
  scheduler: {
    impressionsRefreshRate: 60, // 60 sec
    eventsPushRate:         60, // 60 sec
    eventsQueueSize:       500  // 500 items
  },
  sync: {
    splitFilters: [{
      type: 'byName',
      values: ['split_name_1', 'split_name_2']
    }],
    impressionsMode: 'OPTIMIZED'
  },
  streamingEnabled: true,
  debug: false
});

const sdk: SplitIO.ISDK = SplitFactory({
  startup: {
    readyTimeout:                 10, // 10 sec
    eventsFirstPushWindow:        10  // 10 sec
  },
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'YOUR_KEY'
  },
  scheduler: {
    impressionsRefreshRate: 60, // 60 sec
    eventsPushRate:         60, // 60 sec
    eventsQueueSize:       500  // 500 items
  },
  sync: {
    splitFilters: [{
      type: 'byName',
      values: ['split_name_1', 'split_name_2']
    }],
    impressionsMode: 'OPTIMIZED'
  },
  streamingEnabled: true,
  debug: false
});

var factory = window.splitio.SplitFactory({
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  // Same as SplitFactory, InLocalStorage is exposed on the global splitio object
  storage: window.splitio.InLocalStorage({
    prefix: 'MY_PREFIX'
  })
});

// Now use the SDK as usual
var client = factory.client();

import { SplitFactory, InLocalStorage } from '@splitsoftware/splitio-browserjs';

const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  storage: InLocalStorage({
    prefix: 'MY_PREFIX'
  })
});

// Now use the SDK as usual
const client = factory.client();

var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    // the key can be the logged in
    // user id, or the account id that 
    // the logged in user belongs to. 
    // The type of customer (user, account, custom)
    // is chosen during Split's sign-up process.
    key: 'key'
  }
});

var manager = factory.manager();

manager.once(manager.Event.SDK_READY, function() {
  // Once it's ready, use the manager
});

const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    // the key can be the logged in
    // user id, or the account id that 
    // the logged in user belongs to. 
    // The type of customer (user, account, custom)
    // is chosen during Split's sign-up process.
    key: 'key'
  }
});

const manager: SplitIO.IManager = factory.manager();

manager.once(manager.Event.SDK_READY, function() {
  // Once it's ready, use the manager
});

/**
 * Returns the Split registered with the SDK of this name.
 *
 * @return SplitView or null.
 */
var splitView = manager.split('name-of-split');

/**
 * Retrieves the Splits that are currently registered with the
 * SDK.
 *
 * returns a List of SplitViews.
 */
var splitViewsList = manager.splits();

/** 
 * Returns the names of features (or Splits) registered with the SDK.
 *
 * @return a List of Strings of the features' names.
 */
var splitNamesList = manager.names();

/**
 * Returns the Split registered with the SDK of this name.
 *
 * @return SplitView or null.
 */
const splitView: SplitIO.SplitView = manager.split('name-of-split');

/**
 * Retrieves the Splits that are currently registered with the
 * SDK.
 *
 * returns a List of SplitViews.
 */
const splitViewsList: SplitIO.SplitViews = manager.splits();

/** 
 * Returns the names of features (or Splits) registered with the SDK.
 *
 * @return a List of Strings of the features' names.
 */
const splitNamesList: SplitIO.SplitNames = manager.names();

class SplitView {
  name: string,
  trafficType: string,
  killed: boolean,
  treatments: Array<string>,
  changeNumber: number,
  configs: {
    [treatmentName: string]: string
  }    
}

function logImpression(impressionData) {
  // do something with the impression data.
}

var factory = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  impressionListener: {
    logImpression: logImpression
  }
});

class MyImprListener implements SplitIO.IImpressionListener {
  logImpression(impressionData: SplitIO.ImpressionData) {
    // do something with impressionData
  }
}

const factory: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  impressionListener: {
    logImpression: new MyImprListener()
  }
});

import { SplitFactory, DebugLogger } from '@splitsoftware/splitio-browserjs';

const sdk: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  debug: DebugLogger() // other options are `InfoLogger`, `WarnLogger` and `ErrorLogger`
});

var splitio = require('@splitsoftware/splitio-browserjs');

var sdk = splitio.SplitFactory({
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  debug: splitio.DebugLogger() // other options are `InfoLogger`, `WarnLogger` and `ErrorLogger`
});

var sdk = splitio.SplitFactory({
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  debug: splitio.DebugLogger() // Only the full UMD bundle includes `DebugLogger`, `InfoLogger`, `WarnLogger` and `ErrorLogger` modules in the `splitio` namespace.
});

import { SplitFactory } from '@splitsoftware/splitio-browserjs';

const sdk: SplitIO.ISDK = SplitFactory({ 
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  debug: true // other options are 'ERROR', 'WARN', 'INFO' and 'DEBUG
});

// Or you can use the Logger API methods which have an immediate effect.
sdk.Logger.setLogLevel('WARN'); // Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'
sdk.Logger.enable(); // equivalent to `setLogLevel('DEBUG')`
sdk.Logger.disable(); // equivalent to `setLogLevel('NONE')`

var splitio = require('@splitsoftware/splitio-browserjs');

var sdk = splitio.SplitFactory({
  core: {
    authorizationKey: 'YOUR_API_KEY',
    key: 'key'
  },
  debug: true // other options are 'ERROR', 'WARN', 'INFO' and 'DEBUG
});

// Or you can use the Logger API methods which have an immediate effect.
sdk.Logger.setLogLevel('WARN'); // Acceptable values are: 'DEBUG', 'INFO', 'WARN', 'ERROR', 'NONE'
sdk.Logger.enable(); // equivalent to `setLogLevel('DEBUG')`
sdk.Logger.disable(); // equivalent to `setLogLevel('NONE')`

// Acceptable values are 'on', 'enable' and 'enabled'
localStorage.splitio_debug = 'on' <enter>

var factory = SplitFactory({
  core: {
    authorizationKey: 'YOUR_AUTH_KEY',
    key: 'CUSTOMER_ACCOUNT_ID', 
    // Istantiate the sdk once and provide the ID for one of the
    // traffic types that you plan to release to. It doesn't
    // matter which you pick to start off with.
  },
});

// now when you call factory.client(), the sdk will create a client 
// using the Account ID and traffic type name (if any) 
// you passed in during the factory creation.
var account_client = factory.client();

// to create another client for a User instead, just pass in a User ID 

// This is only valid after at least one client has been initialized.
var user_client = factory.client('CUSTOMER_USER_ID'); 

// check treatment for user-poll and CUSTOMER_USER_ID
var user_poll_treatment = user_client.getTreatment('user-poll');

// check treatment for account-permissioning and CUSTOMER_ACCOUNT_ID
var account_permissioning_treatment = account_client.getTreatment('account-permissioning');

// track events for accounts
user_client.track('account', 'PAGELOAD', 7.86);

// or track events for users
account_client.track('user', 'ACCOUNT_CREATED');

const sdk: SplitIO.ISDK = SplitFactory({
  core: {
    authorizationKey: 'YOUR_AUTH_KEY',
    key: 'CUSTOMER_ACCOUNT_ID' 
    // instantiate the sdk once and provide the ID for one of the
    // traffic types that you plan to release to. It doesn't
    // matter which you pick to start off with. 
  },
});

// now when you call sdk.client(), the sdk will create a client
// using the Account ID you passed in during the factory creation.
const account_client: SplitIO.IClient = factory.client();

// to create another client for a User instead, just pass in a
// User ID to the sdk.client() method. This is only valid after 
// at least one client has been initialized.
const user_client: SplitIO.IClient =
  factory.client('CUSTOMER_USER_ID'); 

// check treatment for user-poll and CUSTOMER_USER_ID
const user_poll_treatment: SplitIO.Treatment =
  user_client.getTreatment('user-poll');

// check treatment for account-permissioning and CUSTOMER_ACCOUNT_ID
const account_permissioning_treatment: SplitIO.Treatment =
  account_client.getTreatment('account-permissioning');

// track events for accounts
user_client.track('account', 'PAGELOAD', 7.86);

// or track events for users
account_client.track('user', 'ACCOUNT_CREATED');

function whenReady() {
  var treatment = client.getTreatment('YOUR_SPLIT');

  if (treatment === 'on') {
    // insert on code
  } else if (treatment === 'off') {
    // insert off code
  } else {
    // insert control code (usually the same as default treatment)
  }
}

// the client is ready for start making evaluations with your data
client.once(client.Event.SDK_READY, whenReady);

client.once(client.Event.SDK_READY_TIMED_OUT, function () {
  // this callback will be called after 1.5 seconds if and only if the client
  // is not ready for that time. You can still call getTreatment() 
  // but it could return CONTROL.
});

client.on(client.Event.SDK_UPDATE, function () {
  // fired each time the client state change. 
  // For example, when a Split or a Segment changes.
  console.log('The SDK has been updated!');
});

// This event will fire only using the LocalStorage option and if there's Split data stored in the browser.
client.once(client.Event.SDK_READY_FROM_CACHE, function () {
  // Fired after the SDK could confirm the presence of the Split data.
  // This event fires really quickly, since there's no actual fetching of information.
  // Keep in mind that data might be stale, this is NOT a replacement of SDK_READY.
});

function whenReady() {
  const treatment: SplitIO.Treatment = client.getTreatment('YOUR_SPLIT');

  if (treatment === 'on') {
    // insert on code
  } else if (treatment === 'off') {
    // insert off code
  } else {
    // insert control code (usually the same as default treatment)
  }
}

// the client is ready for start making evaluations with your data
client.once(client.Event.SDK_READY, whenReady);

client.once(client.Event.SDK_READY_TIMED_OUT, () => {
  // this callback will be called after 1.5 seconds if and only if the client
  // is not ready for that time. You can still call getTreatment() 
  // but it could return CONTROL.
});

client.on(client.Event.SDK_UPDATE, () => {
  // fired each time the client state change. 
  // For example, when a Split or a Segment changes.
  console.log('The SDK has been updated!');
});

// This event will fire only using the LocalStorage option and if there's Split data stored in the browser.
client.once(client.Event.SDK_READY_FROM_CACHE, function () {
  // Fired after the SDK could confirm the presence of the Split data.
  // This event fires really quickly, since there's no actual fetching of information.
  // Keep in mind that data might be stale, this is NOT a replacement of SDK_READY.
});