New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@optimizely/optimizely-sdk

Package Overview
Dependencies
Maintainers
1
Versions
86
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@optimizely/optimizely-sdk - npm Package Compare versions

Comparing version 3.0.1 to 3.1.0-beta1

30

CHANGELOG.MD

@@ -10,2 +10,32 @@ # Changelog

## [3.1.0-beta1] - March 5th, 2019
### Changed
- New APIs for setting `logger` and `logLevel` on the optimizelySDK singleton ([#232](https://github.com/optimizely/javascript-sdk/pull/232))
- `logger` and `logLevel` are now set globally for all instances of Optimizely. If you were passing
different loggers to individual instances of Optimizely, logging behavior may now be different.
#### Setting a ConsoleLogger
```js
var optimizelySDK = require('@optimizely/optimizely-sdk')
// logger and logLevel are now set on the optimizelySDK singleton
optimizelySDK.setLogger(optimizelySDK.logging.createLogger())
// valid levels: 'DEBUG', 'INFO', 'WARN', 'ERROR'
optimizelySDK.setLogLevel('WARN')
// enums can also be used
optimizelySDK.setLogLevel(optimizely.enums.LOG_LEVEL.ERROR)
```
#### Disable logging
```js
var optimizelySDK = require('@optimizely/optimizely-sdk')
optimizelySDK.setLogger(null)
```
## [3.0.1] - February 21, 2019

@@ -12,0 +42,0 @@

75

lib/index.browser.js

@@ -16,2 +16,3 @@ /**

*/
var logging = require('@optimizely/js-sdk-logging');
var fns = require('./utils/fns');

@@ -22,9 +23,9 @@ var configValidator = require('./utils/config_validator');

var enums = require('./utils/enums');
var logger = require('./plugins/logger');
var loggerPlugin = require('./plugins/logger');
var Optimizely = require('./optimizely');
var MODULE_NAME = 'INDEX';
var logger = logging.getLogger();
logging.setLogHandler(loggerPlugin.createLogger());
logging.setLogLevel(logging.LogLevel.INFO);
/**

@@ -34,3 +35,3 @@ * Entry point into the Optimizely Browser SDK

module.exports = {
logging: logger,
logging: loggerPlugin,
errorHandler: defaultErrorHandler,

@@ -40,2 +41,5 @@ eventDispatcher: defaultEventDispatcher,

setLogger: logging.setLogHandler,
setLogLevel: logging.setLogLevel,
/**

@@ -54,20 +58,27 @@ * Creates an instance of the Optimizely class

try {
var logLevel = 'logLevel' in config ? config.logLevel : enums.LOG_LEVEL.INFO;
var defaultLogger = logger.createLogger({logLevel: enums.LOG_LEVEL.INFO});
if (config) {
try {
configValidator.validate(config);
config.isValidInstance = true;
} catch (ex) {
var errorMessage = MODULE_NAME + ':' + ex.message;
if (config.logger) {
config.logger.log(enums.LOG_LEVEL.ERROR, errorMessage);
} else {
defaultLogger.log(enums.LOG_LEVEL.ERROR, errorMessage);
}
config.isValidInstance = false;
}
config = config || {};
// TODO warn about setting per instance errorHandler / logger / logLevel
if (config.errorHandler) {
logging.setErrorHandler(config.errorHandler);
}
if (config.logger) {
logging.setLogHandler(config.logger);
// respect the logger's shouldLog functionality
logging.setLogLevel(logging.LogLevel.NOTSET);
}
if (config.logLevel !== undefined) {
logging.setLogLevel(config.logLevel);
}
try {
configValidator.validate(config);
config.isValidInstance = true;
} catch (ex) {
logger.error(ex);
config.isValidInstance = false;
}
// Explicitly check for null or undefined
// prettier-ignore
if (config.skipJSONValidation == null) { // eslint-disable-line eqeqeq

@@ -77,19 +88,21 @@ config.skipJSONValidation = true;

config = fns.assignIn({
clientEngine: enums.JAVASCRIPT_CLIENT_ENGINE,
errorHandler: defaultErrorHandler,
eventDispatcher: defaultEventDispatcher,
logger: logger.createLogger({logLevel: logLevel})
}, config);
config = fns.assignIn(
{
eventDispatcher: defaultEventDispatcher,
},
config,
{
clientEngine: enums.JAVASCRIPT_CLIENT_ENGINE,
// always get the OptimizelyLogger facade from logging
logger: logger,
errorHandler: logging.getErrorHandler(),
}
);
return new Optimizely(config);
} catch (e) {
config.logger.log(enums.LOG_LEVEL.ERROR, e.message);
config.errorHandler.handleError(e);
logger.error(e);
return null;
}
},
};

45

lib/index.browser.tests.js

@@ -16,2 +16,3 @@ /**

*/
var logging = require('@optimizely/js-sdk-logging');
var configValidator = require('./utils/config_validator');

@@ -88,3 +89,3 @@ var Optimizely = require('./optimizely');

assert.instanceOf(optlyInstance, Optimizely);
assert.equal(optlyInstance.clientVersion, '3.0.1');
assert.equal(optlyInstance.clientVersion, '3.1.0-beta1');
});

@@ -256,34 +257,38 @@

describe('automatically created logger instances', function() {
describe('when passing in logLevel', function() {
beforeEach(function() {
sinon.stub(optimizelyFactory.logging, 'createLogger').callsFake(function() {
return {
log: function() {},
};
});
sinon.stub(logging, 'setLogLevel');
});
afterEach(function() {
optimizelyFactory.logging.createLogger.restore();
logging.setLogLevel.restore();
});
it('should instantiate the logger with a custom logLevel when provided', function() {
var optlyInstance = optimizelyFactory.createInstance({
it('should call logging.setLogLevel', function() {
optimizelyFactory.createInstance({
datafile: testData.getTestProjectConfig(),
logLevel: optimizelyFactory.enums.LOG_LEVEL.ERROR,
});
var foundCall = find(optimizelyFactory.logging.createLogger.getCalls(), function(call) {
return call.returned(sinon.match.same(optlyInstance.logger));
});
assert.strictEqual(foundCall.args[0].logLevel, optimizelyFactory.enums.LOG_LEVEL.ERROR);
sinon.assert.calledOnce(logging.setLogLevel);
sinon.assert.calledWithExactly(logging.setLogLevel, optimizelyFactory.enums.LOG_LEVEL.ERROR);
});
});
it('should default to INFO when no logLevel is provided', function() {
var optlyInstance = optimizelyFactory.createInstance({
describe('when passing in logger', function() {
beforeEach(function() {
sinon.stub(logging, 'setLogHandler');
});
afterEach(function() {
logging.setLogHandler.restore();
});
it('should call logging.setLogHandler with the supplied logger', function() {
var fakeLogger = { log: function() {} };
optimizelyFactory.createInstance({
datafile: testData.getTestProjectConfig(),
logger: fakeLogger,
});
var foundCall = find(optimizelyFactory.logging.createLogger.getCalls(), function(call) {
return call.returned(sinon.match.same(optlyInstance.logger));
});
assert.strictEqual(foundCall.args[0].logLevel, optimizelyFactory.enums.LOG_LEVEL.INFO);
sinon.assert.calledOnce(logging.setLogHandler);
sinon.assert.calledWithExactly(logging.setLogHandler, fakeLogger);
});

@@ -290,0 +295,0 @@ });

126

lib/index.browser.umdtests.js

@@ -19,3 +19,3 @@ /**

var logger = require('./plugins/logger');
var Optimizely = require('./optimizely');
var packageJSON = require('../package.json');

@@ -27,3 +27,2 @@ var eventDispatcher = require('./plugins/event_dispatcher/index.browser');

var assert = chai.assert;
var find = require('lodash/find');
var sinon = require('sinon');

@@ -36,4 +35,4 @@

describe('createInstance', function() {
var fakeErrorHandler = { handleError: function() {}};
var fakeEventDispatcher = { dispatchEvent: function() {}};
var fakeErrorHandler = { handleError: function() {} };
var fakeEventDispatcher = { dispatchEvent: function() {} };
var silentLogger;

@@ -46,3 +45,2 @@

});
sinon.spy(console, 'error');
sinon.stub(configValidator, 'validate');

@@ -53,8 +51,16 @@

requests = [];
xhr.onCreate = function (req) {
requests.push(req);
xhr.onCreate = function(req) {
requests.push(req);
};
sinon.spy(console, 'log');
sinon.spy(console, 'info');
sinon.spy(console, 'warn');
sinon.spy(console, 'error');
});
afterEach(function() {
console.log.restore();
console.info.restore();
console.warn.restore();
console.error.restore();

@@ -65,2 +71,33 @@ configValidator.validate.restore();

// this test has to come first due to local state of the logLevel
it('should default to INFO when no logLevel is provided', function() {
// checking that INFO logs log for an unspecified logLevel
var optlyInstance = window.optimizelySdk.createInstance({
datafile: testData.getTestProjectConfig(),
skipJSONValidation: true,
});
assert.strictEqual(console.info.getCalls().length, 1);
call = console.info.getCalls()[0];
assert.strictEqual(call.args.length, 1);
assert(call.args[0].indexOf('OPTIMIZELY: Skipping JSON schema validation.') > -1);
});
it('should instantiate the logger with a custom logLevel when provided', function() {
// checking that INFO logs do not log for a logLevel of ERROR
var optlyInstance = window.optimizelySdk.createInstance({
datafile: testData.getTestProjectConfig(),
logLevel: enums.LOG_LEVEL.ERROR,
skipJSONValidation: true,
});
assert.strictEqual(console.log.getCalls().length, 0);
// checking that ERROR logs do log for a logLevel of ERROR
var optlyInstanceInvalid = window.optimizelySdk.createInstance({
datafile: {},
logLevel: enums.LOG_LEVEL.ERROR,
});
optlyInstance.activate('testExperiment', 'testUser');
assert.strictEqual(console.error.getCalls().length, 1);
});
it('should not throw if the provided config is not valid', function() {

@@ -145,6 +182,9 @@ configValidator.validate.throws(new Error('Invalid config or something'));

var didSetVariation2 = optlyInstance.setForcedVariation('testExperimentLaunched', 'testUser', 'controlLaunched');
var didSetVariation2 = optlyInstance.setForcedVariation(
'testExperimentLaunched',
'testUser',
'controlLaunched'
);
assert.strictEqual(didSetVariation2, true);
var variation = optlyInstance.getForcedVariation('testExperiment', 'testUser');

@@ -168,3 +208,7 @@ assert.strictEqual(variation, 'control');

var didSetVariation2 = optlyInstance.setForcedVariation('testExperimentLaunched', 'testUser', 'controlLaunched');
var didSetVariation2 = optlyInstance.setForcedVariation(
'testExperimentLaunched',
'testUser',
'controlLaunched'
);
assert.strictEqual(didSetVariation2, true);

@@ -193,6 +237,14 @@

var didSetVariation2 = optlyInstance.setForcedVariation('testExperimentLaunched', 'testUser', 'controlLaunched');
var didSetVariation2 = optlyInstance.setForcedVariation(
'testExperimentLaunched',
'testUser',
'controlLaunched'
);
assert.strictEqual(didSetVariation2, true);
var didSetVariation2 = optlyInstance.setForcedVariation('testExperimentLaunched', 'testUser', 'variationLaunched');
var didSetVariation2 = optlyInstance.setForcedVariation(
'testExperimentLaunched',
'testUser',
'variationLaunched'
);
assert.strictEqual(didSetVariation2, true);

@@ -236,3 +288,7 @@

var didSetVariation = optlyInstance.setForcedVariation('testExperimentNotRunning', 'testUser', 'controlNotRunning');
var didSetVariation = optlyInstance.setForcedVariation(
'testExperimentNotRunning',
'testUser',
'controlNotRunning'
);
assert.strictEqual(didSetVariation, true);

@@ -243,48 +299,4 @@

});
describe('automatically created logger instances', function() {
beforeEach(function() {
sinon.spy(console, 'log');
sinon.spy(console, 'info');
sinon.spy(console, 'warn');
});
afterEach(function() {
console.log.restore();
console.info.restore();
console.warn.restore();
});
it('should instantiate the logger with a custom logLevel when provided', function() {
// checking that INFO logs do not log for a logLevel of ERROR
var optlyInstance = window.optimizelySdk.createInstance({
datafile: testData.getTestProjectConfig(),
logLevel: enums.LOG_LEVEL.ERROR,
skipJSONValidation: true
});
assert.strictEqual(console.log.getCalls().length, 0)
// checking that ERROR logs do log for a logLevel of ERROR
var optlyInstanceInvalid = window.optimizelySdk.createInstance({
datafile: {},
logLevel: enums.LOG_LEVEL.ERROR
});
optlyInstance.activate('testExperiment', 'testUser')
assert.strictEqual(console.error.getCalls().length, 1)
});
it('should default to INFO when no logLevel is provided', function() {
// checking that INFO logs log for an unspecified logLevel
var optlyInstance = window.optimizelySdk.createInstance({
datafile: testData.getTestProjectConfig(),
skipJSONValidation: true
});
assert.strictEqual(console.info.getCalls().length, 1);
call = console.info.getCalls()[0];
assert.strictEqual(call.args.length, 1);
assert(call.args[0].indexOf('OPTIMIZELY: Skipping JSON schema validation.') > -1);
});
});
});
});
});

72

lib/index.node.js

@@ -16,3 +16,3 @@ /****************************************************************************

***************************************************************************/
var logging = require('@optimizely/js-sdk-logging');
var configValidator = require('./utils/config_validator');

@@ -24,8 +24,8 @@ var defaultErrorHandler = require('./plugins/error_handler');

var jsonSchemaValidator = require('./utils/json_schema_validator');
var logger = require('./plugins/logger');
var sprintf = require('sprintf-js').sprintf;
var loggerPlugin = require('./plugins/logger');
var Optimizely = require('./optimizely');
var MODULE_NAME = 'INDEX';
var logger = logging.getLogger();
logging.setLogLevel(logging.LogLevel.ERROR);

@@ -36,3 +36,3 @@ /**

module.exports = {
logging: logger,
logging: loggerPlugin,
errorHandler: defaultErrorHandler,

@@ -42,2 +42,5 @@ eventDispatcher: defaultEventDispatcher,

setLogger: logging.setLogHandler,
setLogLevel: logging.setLogLevel,
/**

@@ -55,4 +58,21 @@ * Creates an instance of the Optimizely class

createInstance: function(config) {
var defaultLogger = logger.createNoOpLogger();
if (config) {
try {
var hasLogger = false;
config = config || {};
// TODO warn about setting per instance errorHandler / logger / logLevel
if (config.errorHandler) {
logging.setErrorHandler(config.errorHandler);
}
if (config.logger) {
// only set a logger in node if one is provided, by not setting we are noop-ing
hasLogger = true;
logging.setLogHandler(config.logger);
// respect the logger's shouldLog functionality
logging.setLogLevel(logging.LogLevel.NOTSET);
}
if (config.logLevel !== undefined) {
logging.setLogLevel(config.logLevel);
}
try {

@@ -62,23 +82,31 @@ configValidator.validate(config);

} catch (ex) {
if (config.logger) {
config.logger.log(enums.LOG_LEVEL.ERROR, sprintf('%s: %s', MODULE_NAME, ex.message));
if (hasLogger) {
logger.error(ex);
} else {
var simpleLogger = logger.createLogger({logLevel: 4});
simpleLogger.log(enums.LOG_LEVEL.ERROR, sprintf('%s: %s', MODULE_NAME, ex.message));
console.error(ex.message);
}
config.isValidInstance = false;
}
}
config = fns.assign({
clientEngine: enums.NODE_CLIENT_ENGINE,
errorHandler: defaultErrorHandler,
eventDispatcher: defaultEventDispatcher,
jsonSchemaValidator: jsonSchemaValidator,
logger: defaultLogger,
skipJSONValidation: false
}, config);
config = fns.assign(
{
eventDispatcher: defaultEventDispatcher,
jsonSchemaValidator: jsonSchemaValidator,
skipJSONValidation: false,
},
config,
{
clientEngine: enums.NODE_CLIENT_ENGINE,
// always get the OptimizelyLogger facade from logging
logger: logger,
errorHandler: logging.getErrorHandler(),
}
);
return new Optimizely(config);
}
return new Optimizely(config);
} catch (e) {
logger.error(e);
return null;
}
},
};

22

lib/index.node.tests.js

@@ -16,5 +16,6 @@ /**

*/
var logging = require('@optimizely/js-sdk-logging');
var configValidator = require('./utils/config_validator');
var enums = require('./utils/enums');
var logger = require('./plugins/logger');
var loggerPlugin = require('./plugins/logger');
var Optimizely = require('./optimizely');

@@ -44,10 +45,12 @@ var optimizelyFactory = require('./index.node');

beforeEach(function() {
fakeLogger = { log: sinon.spy() };
sinon.stub(logger, 'createLogger').returns(fakeLogger);
fakeLogger = { log: sinon.spy(), setLogLevel: sinon.spy() };
sinon.stub(loggerPlugin, 'createLogger').returns(fakeLogger);
sinon.stub(configValidator, 'validate');
sinon.stub(console, 'error');
});
afterEach(function() {
logger.createLogger.restore();
loggerPlugin.createLogger.restore();
configValidator.validate.restore();
console.error.restore();
});

@@ -57,12 +60,13 @@

configValidator.validate.throws(new Error('Invalid config or something'));
var localLogger = loggerPlugin.createLogger({ logLevel: enums.LOG_LEVEL.INFO });
assert.doesNotThrow(function() {
optimizelyFactory.createInstance({
datafile: {},
logger: logger.createLogger({ logLevel: enums.LOG_LEVEL.INFO }),
logger: localLogger,
});
});
sinon.assert.calledWith(fakeLogger.log, enums.LOG_LEVEL.ERROR);
sinon.assert.calledWith(localLogger.log, enums.LOG_LEVEL.ERROR);
});
it('should not throw if the provided config is not valid and log an error if no-op logger is used', function() {
it('should not throw if the provided config is not valid and log an error if no logger is provided', function() {
configValidator.validate.throws(new Error('Invalid config or something'));

@@ -74,3 +78,3 @@ assert.doesNotThrow(function() {

});
sinon.assert.calledWith(fakeLogger.log, enums.LOG_LEVEL.ERROR);
sinon.assert.calledOnce(console.error);
});

@@ -87,3 +91,3 @@

assert.instanceOf(optlyInstance, Optimizely);
assert.equal(optlyInstance.clientVersion, '3.0.1');
assert.equal(optlyInstance.clientVersion, '3.1.0-beta1');
});

@@ -90,0 +94,0 @@ });

8

lib/plugins/logger/enums.js

@@ -16,8 +16,2 @@ /**

*/
exports.LOG_LEVEL = {
NOTSET: 0,
DEBUG: 1,
INFO: 2,
WARNING: 3,
ERROR: 4,
};
exports.LOG_LEVEL = require('@optimizely/js-sdk-logging').LogLevel;

128

lib/plugins/logger/index.js

@@ -16,11 +16,4 @@ /**

*/
var fns = require('../../utils/fns');
var enums = require('../../utils/enums');
var sprintf = require('sprintf-js').sprintf;
var logging = require('@optimizely/js-sdk-logging');
var MODULE_NAME = 'DEFAULT_LOGGER';
/**
* Default logger implementation
*/
function NoOpLogger() {}

@@ -30,120 +23,7 @@

/**
* Simple logger implementation
* @param {Object} config Configuration options for the logger
* @param {Boolean} config.logLevel The default log level
* @param {Boolean} config.logToConsole True to log to the console
* @param {string} config.prefix Prefix to prepend to the log message
*/
function Logger(config) {
config = fns.assignIn({
logLevel: enums.LOG_LEVEL.ERROR,
logToConsole: true,
prefix: '[OPTIMIZELY]',
}, config);
this.logToConsole = config.logToConsole;
this.prefix = config.prefix;
this.setLogLevel(config.logLevel);
}
/**
* Log the given message at the specified verbosity
* @param {string} logLevel Verbosity level
* @param {string} logMessage Message to log
*/
Logger.prototype.log = function(logLevel, logMessage) {
if (this.__shouldLog(logLevel)) {
if (this.prefix) {
var logLevelName = getLogLevelName(logLevel);
logMessage = sprintf(
enums.DEFAULT_LOGGER_MESSAGE_TEMPLATE,
this.prefix, logLevelName, getTime(), logMessage
);
}
if (this.logToConsole) {
this.__consoleLog(logLevel, [logMessage]);
}
}
};
/**
* Set the current verbosity level
* @param {string} logLevel Verbosity level to set the logger to
*/
Logger.prototype.setLogLevel = function(logLevel) {
// Check that logLevel is valid, otherwise default to ERROR
this.logLevel = (fns.values(enums.LOG_LEVEL).indexOf(logLevel) > -1) ? logLevel : enums.LOG_LEVEL.ERROR;
var logLevelName = getLogLevelName(this.logLevel);
this.log(enums.LOG_LEVEL.DEBUG, sprintf(enums.LOG_MESSAGES.SET_LOG_LEVEL, MODULE_NAME, logLevelName));
};
/**
* Determine whether we should log based on the current verbosity level
* @param {string} targetLogLevel Verbosity level to check against to determine
* whether we sould log or not
* @return {Boolean} true if we should log based on the given log level
* @private
*/
Logger.prototype.__shouldLog = function(targetLogLevel) {
return targetLogLevel >= this.logLevel;
};
/**
* Logs to the console
* @param {string} logLevel Verbosity level to log at
* @param {Array<string>} logArguments Array of strings to log (will be concatenated)
* @private
*/
Logger.prototype.__consoleLog = function(logLevel, logArguments) {
switch (logLevel) {
case enums.LOG_LEVEL.DEBUG:
console.log.apply(console, logArguments);
break;
case enums.LOG_LEVEL.INFO:
console.info.apply(console, logArguments);
break;
case enums.LOG_LEVEL.WARNING:
console.warn.apply(console, logArguments);
break;
case enums.LOG_LEVEL.ERROR:
console.error.apply(console, logArguments);
break;
default:
console.log.apply(console, logArguments);
}
};
/**
* Get log level name
* @param {string} logLevel Verbosity level to log at
* @return {string} String name of log level
*/
function getLogLevelName(logLevel) {
switch (logLevel) {
case enums.LOG_LEVEL.DEBUG:
return 'DEBUG';
case enums.LOG_LEVEL.INFO:
return 'INFO';
case enums.LOG_LEVEL.WARNING:
return 'WARNING';
case enums.LOG_LEVEL.ERROR:
return 'ERROR';
default:
return 'NOTSET';
}
}
/**
* Get time
*/
function getTime() {
return new Date();
}
module.exports = {
createLogger: function(config) {
return new Logger(config);
createLogger: function(opts) {
return new logging.ConsoleLogHandler(opts);
},
createNoOpLogger: function() {

@@ -150,0 +30,0 @@ return new NoOpLogger();

2

lib/plugins/logger/index.tests.js

@@ -68,3 +68,3 @@ /**

sinon.assert.calledOnce(console.warn);
sinon.assert.calledWithExactly(console.warn, sinon.match(/.*WARNING.*message.*/));
sinon.assert.calledWithExactly(console.warn, sinon.match(/.*WARN.*message.*/));
sinon.assert.notCalled(console.error);

@@ -71,0 +71,0 @@ });

5

lib/utils/enums/index.js

@@ -91,3 +91,2 @@ /****************************************************************************

SAVED_VARIATION_NOT_FOUND: '%s: User %s was previously bucketed into variation with ID %s for experiment %s, but no matching variation was found.',
SET_LOG_LEVEL: '%s: Setting log level to "%s"',
SHOULD_NOT_DISPATCH_ACTIVATE: '%s: Experiment %s is in "Launched" state. Not activating user.',

@@ -141,4 +140,2 @@ SKIPPING_JSON_VALIDATION: '%s: Skipping JSON schema validation.',

exports.DEFAULT_LOGGER_MESSAGE_TEMPLATE = '%s - %s %s %s';
exports.RESERVED_EVENT_KEYWORDS = {

@@ -158,3 +155,3 @@ REVENUE: 'revenue',

exports.NODE_CLIENT_ENGINE = 'node-sdk';
exports.NODE_CLIENT_VERSION = '3.0.1';
exports.NODE_CLIENT_VERSION = '3.1.0-beta1';

@@ -161,0 +158,0 @@ /*

8

package.json
{
"name": "@optimizely/optimizely-sdk",
"version": "3.0.1",
"version": "3.1.0-beta1",
"description": "JavaScript SDK for Optimizely X Full Stack",

@@ -9,3 +9,3 @@ "main": "lib/index.node.js",

"scripts": {
"test": "mocha ./lib/*.tests.js ./lib/**/*.tests.js ./lib/**/**/*tests.js --recursive",
"test": "mocha ./lib/*.tests.js ./lib/**/*.tests.js ./lib/**/**/*tests.js --recursive --exit",
"test-xbrowser": "karma start karma.bs.conf.js --single-run",

@@ -36,2 +36,3 @@ "test-umdbrowser": "npm run build-browser-umd && karma start karma.umd.conf.js --single-run",

"dependencies": {
"@optimizely/js-sdk-logging": "^0.1.0",
"json-schema": "^0.2.3",

@@ -72,4 +73,5 @@ "lodash": "^4.0.0",

"CHANGELOG",
"README.md"
"README.md",
"package.json"
]
}
dist/optimizely.browser.umd.js

Sorry, the diff of this file is too big to display

dist/optimizely.browser.umd.min.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc