bv-ui-core 0.1.1

package/lib/loader/index.js

@@ -0,0 +1,358 @@
+/* eslint no-use-before-define: 0 */
+/**
+ * @fileOverview
+ * Load JavaScript and CSS at runtime.
+ *
+ * This module is derived from yepnope.js 2.0.0:
+ * Copyright (c) 2014, Alex Sexton
+ * Copyright (c) 2014, Ralph Holzmann
+ * All rights reserved.
+ * New BSD license:
+ * https://github.com/SlexAxton/yepnope.js/blob/master/LICENSE.md
+ *
+ * @module
+ */
+
+var global = require('../global');
+var namespacer = require('../namespacer');
+var doc = global.document;
+
+var DEFAULT_TIMEOUT = 10000;
+var loadedUrls = {};
+
+function getFirstScript () {
+  return doc.getElementsByTagName('script')[0];
+}
+
+function isFileReady (readyState) {
+  // the file is ready if there is no readyState, or if it has reached a
+  // terminal state.
+  return !readyState ||
+    readyState === 'loaded' ||
+    readyState === 'complete' ||
+    readyState === 'uninitialized';
+}
+
+function validateArguments (url, options, callback) {
+  if (!url || typeof url !== 'string') {
+    throw new Error('`url` must be a string');
+  }
+
+  if (options.namespaceName && typeof options.namespaceName !== 'string') {
+    throw new Error('`options.namespaceName` must be a string');
+  }
+
+  if (options.forceLoad && typeof options.forceLoad !== 'boolean') {
+    throw new Error('`options.forceLoad` must be a boolean');
+  }
+
+  if (typeof options.timeout !== 'number') {
+    throw new Error('`options.timeout` must be a number');
+  }
+
+  if (callback && typeof callback !== 'function') {
+    throw new Error('`callback` must be a function');
+  }
+}
+
+module.exports = {
+  /**
+   * Clears the loaded URLs
+   *
+   * Clears any URLs that might have been stored in the loadedUrls hash, either
+   * locally or in the given namespace(optional). This is needed for testing so
+   * we don't need unique URLs for every test, but rather this can be used as a
+   * means of cleaning up.
+   *
+   * @param {string} [namespace] - contains the name of the namespace to clear
+   *  the loadedUrls hash in.
+   */
+  _clearLoadedUrls: function (namespaceName) {
+    if (namespaceName) {
+      var namespace = namespacer.namespace(namespaceName);
+      namespace.loadedUrls = {};
+    }
+    else {
+      loadedUrls = {};
+    }
+  },
+
+  /**
+   * Load a script from a URL
+   *
+   * The script is loaded on a later turn of the event loop. If a callback is
+   * provided, it will be invoked on success in all supported browsers. The
+   * callback will execute after the script.
+   *
+   * In modern IE and other browsers, the callback will be invoked with an error
+   * on failure as well. A timeout in milliseconds may be provided as
+   * `options.timeout`. If this timeout expires before loading fails or
+   * succeeds, the callback will be invoked with an error.
+   *
+   * @param {string} url - URL of the script
+   * @param {object} [options]
+   * @param {object} options.attributes - an object containing key/value pairs
+   *  to be used as attributes on the created `script` element (optional)
+   * @param {number} options.timeout - timeout in milliseconds (defaults to
+   *  10000ms)
+   * @param {boolean} options.forceLoad - whether to load the script at the
+   *  specified url or not regardless of whether an earlier attempt to do so has
+   *  already been made
+   * @param {string} options.namespaceName - the name of the namespace to check
+   *  if the script has been previously loaded and store the loadedUrls hash
+   * @param {function} [callback] - node-style callback
+   */
+  loadScript: function (url, options, callback) {
+    var _loadedUrls = loadedUrls;
+    var namespace;
+
+    if (typeof options === 'function') {
+      callback = options;
+      options = null;
+    }
+
+    options = options || {};
+    options.timeout = options.timeout || DEFAULT_TIMEOUT;
+
+    validateArguments(url, options, callback);
+
+    /**
+     * The goal of using the namespacer is to allow multiple apps on the same
+     * page to share the properties within the namespace, namely loadedUrls. For
+     * this reason, we are forgoing the use of registerProperty to instantiate
+     * the list of loaded URLs. This will allow the loader module to be run in
+     * different apps but access the same namespace property.
+     */
+
+    if (options.namespaceName) {
+      namespace = namespacer.namespace(options.namespaceName);
+      _loadedUrls = namespace.loadedUrls || {};
+    }
+
+    if (!options.forceLoad && _loadedUrls[url]) {
+      // File at given url has already been loaded and option has not been set
+      // to reload it, so we'll just call the callback and return.
+      if (typeof callback === 'function') {
+        callback();
+      }
+      return;
+    }
+
+    var script = doc.createElement('script');
+    var done = false;
+    var attr;
+
+    if (options.attributes) {
+      for (attr in options.attributes) {
+        script.setAttribute(attr, options.attributes[attr]);
+      }
+    }
+
+    function cleanUp (err) {
+      done = true;
+      clearTimeout(timeoutHandle);
+      script.onload = script.onreadystatechange = script.onerror = null;
+      if (script && script.parentNode) {
+        script.parentNode.removeChild(script);
+      }
+      if (!err) {
+        _loadedUrls[url] = true;
+
+        if (options.namespaceName) {
+          namespace.loadedUrls = _loadedUrls;
+        }
+        else {
+          loadedUrls = _loadedUrls;
+        }
+      }
+
+      if (typeof callback === 'function') {
+        callback(err);
+      }
+    }
+
+    script.onreadystatechange = script.onload = function () {
+      if (done || !isFileReady(script.readyState)) {
+        return;
+      }
+
+      cleanUp();
+    };
+
+    script.onerror = function () {
+      if (done) {
+        return;
+      }
+
+      cleanUp(new Error('Error: could not load ' + url));
+    };
+
+    // We should be able to catch most errors with onerror, but for browsers
+    // that don't support onerror we provide the below timeout cb
+    var timeoutHandle = setTimeout(function () {
+      if (done) {
+        return;
+      }
+
+      cleanUp(new Error('Error: script timeout ' + url));
+    }, options.timeout);
+
+    // If a script is cached, IE may execute it immediately, which breaks
+    // JavaScript's run-to-completion semantics. So, don't try to load the
+    // script until a later turn of the event loop.
+    //
+    // See http://www.guypo.com/ies-premature-execution-problem/
+    setTimeout(function () {
+      script.src = url;
+
+      var firstScript = getFirstScript();
+
+      firstScript.parentNode.insertBefore(script, firstScript);
+    }, 0);
+  },
+
+  /**
+   * Load a stylesheet from a URL
+   *
+   * The stylesheet is loaded on a later turn of the event loop. If a callback
+   * is provided, it will be invoked on success in all supported browsers.
+   *
+   * In modern IE and other browsers, the callback will be invoked with an error
+   * on failure as well. A timeout in milliseconds may be provided as
+   * `options.timeout`. If this timeout expires before loading fails or
+   * succeeds, the callback will be invoked with an error.
+   *
+   * @param {string} url - URL of the stylesheet
+   * @param {object} [options]
+   * @param {object} options.attributes - an object containing key/value pairs
+   *  to be used as attributes on the created `link` element (optional)
+   * @param {number} options.timeout - timeout in milliseconds (defaults to
+   *  1000ms)
+   * @param {boolean} options.forceLoad - whether to load the style sheet at the
+   *  specified url or not regardless of whether an earlier attempt to do so has
+   *  already been made
+   * @param {string} options.namespaceName - the name of the namespace to check
+   *  if the stylesheet has been previously loaded and store the loadedUrls hash
+   * @param {element} options.injectionNode - node to inject link element
+   *  into (defaults to parent node of the first script node)
+   * @param {function} [callback] - node-style callback
+   */
+  loadStyleSheet: function (url, options, callback) {
+    var _loadedUrls = loadedUrls;
+    var namespace;
+
+    if (typeof options === 'function') {
+      callback = options;
+      options = null;
+    }
+    options = options || {};
+    options.timeout = options.timeout || DEFAULT_TIMEOUT;
+
+    validateArguments(url, options, callback);
+
+    // This check doesn't happen in `validateArguments` because it's unique
+    // to `loadStyleSheet`.
+    if (
+      'injectionNode' in options &&
+      !(options.injectionNode instanceof global.Element)
+    ) {
+      throw new Error('`options.injectionNode` must be a DOM node');
+    }
+
+    /**
+     * The goal of using the namespacer is to allow multiple apps on the same
+     * page to share the properties within the namespace, namely loadedUrls. For
+     * this reason, we are forgoing the use of registerProperty to instantiate
+     * the list of loaded URLs. This will allow the loader module to be run in
+     * different apps but access the same namespace property.
+     */
+
+    if (options.namespaceName) {
+      namespace = namespacer.namespace(options.namespaceName);
+      _loadedUrls = namespace.loadedUrls || {};
+    }
+
+    if (!options.forceLoad && _loadedUrls[url]) {
+      // File at given url has already been loaded and option has not been set
+      // to reload it, so we'll just call the callback and return.
+      if (typeof callback === 'function') {
+        callback();
+      }
+      return;
+    }
+
+    var link = doc.createElement('link');
+    var done = false;
+    var attr;
+
+    if (options.attributes) {
+      for (attr in options.attributes) {
+        link.setAttribute(attr, options.attributes[attr]);
+      }
+    }
+
+    function cleanUp (err) {
+      done = true;
+      clearTimeout(timeoutHandle);
+      link.onload = link.onreadystatechange = link.onerror = null;
+
+      if (!err) {
+        _loadedUrls[url] = true;
+
+        if (options.namespaceName) {
+          namespace.loadedUrls = _loadedUrls;
+        }
+        else {
+          loadedUrls = _loadedUrls;
+        }
+      }
+
+      if (typeof callback === 'function') {
+        callback(err);
+      }
+    }
+
+    link.onreadystatechange = link.onload = function () {
+      if (done || !isFileReady(link.readyState)) {
+        return;
+      }
+
+      cleanUp();
+    };
+
+    link.onerror = function () {
+      if (done) {
+        return;
+      }
+
+      cleanUp(new Error('Error: could not load ' + url));
+    };
+
+    var timeoutHandle = setTimeout(link.onerror, options.timeout);
+
+    // Inject the stylesheet on a later turn of the event loop
+    setTimeout(function () {
+      // technique to force non-blocking loading from:
+      // https://github.com/filamentgroup/loadCSS/blob/master/loadCSS.js#L20
+      link.media = 'only x';
+
+      link.rel = 'stylesheet';
+      link.type = 'text/css';
+      link.href = url;
+
+      // on next tick, set `media` back
+      setTimeout(function () {
+        link.media = 'all';
+      }, 0);
+
+      var injectionNode = options.injectionNode || getFirstScript().parentNode;
+
+      try {
+        injectionNode.appendChild(link);
+      }
+      catch (error) {
+        cleanUp(new Error('Error: could not append LINK element'));
+      }
+    }, 0);
+  }
+};

package/lib/logger/README.md

@@ -0,0 +1,82 @@
+# logger
+
+The `logger` module provides an object that wraps various console logging methods safely. The default level is OFF, but it is recommended that you set this according to your environment either at build time or by a cookie in the browser in the format `_bvui_debug=loglevel:1`.
+
+## Usage
+
+```javascript
+var Logger = require('bv-ui-core/lib/logger');
+// <method> is one of the 5 types, ex: log
+Logger.<method>('Hello, world!') // console.log('Hello, world!')
+```
+
+## Other Methods
+### Logger.setLogLevel
+
+Set the log level to one of the following to prevent logging under the specified level.
+```
+Logger.DEBUG
+Logger.LOG
+Logger.INFO
+Logger.WARN
+Logger.ERROR
+Logger.OFF
+```
+
+```javascript
+var Logger = require('bv-ui-core/lib/logger');
+
+// Set's the default log level to one of the valid levels
+// DEBUG, LOG, INFO, WARN, ERROR, OFF
+Logger.setLogLevel(Logger.DEBUG)
+
+Logger.log('Hello, World!') // Prints Hello, World!
+
+Logger.setLogLevel(Logger.INFO)
+
+Logger.log('Hello, World!') // Prints nothing because of logLevel
+```
+
+If you have set the logLevel via cookie, any calls to `setLogLevel` in your application will be ignored unless you also pass a force param.
+
+```javascript
+setLogLevel(Logger.LOG, true); // forces LogLevel to LOG
+```
+
+### Logger.group/Logger.groupEnd
+https://developer.mozilla.org/en-US/docs/Web/API/console/group
+
+### Logger.time/Logger.timeEnd
+https://developer.mozilla.org/en-US/docs/Web/API/console/time
+
+### Logger.assert
+
+Assertions can be made if `logLevel` is not `Logger.OFF`. You can assert a function's result or a boolean value.
+
+```javascript
+Logger.assert(() => {
+  return false;
+  }, 'The function failed!'
+);
+
+Logger.assert(true === false, 'Obviously, I failed.');
+```
+
+## Bookmarklet
+
+You can use the following bookmarklet in a browser to specify your loglevel. Save the below script as a bookmark and click on it when you want to modify the stored cookie value.
+
+```javascript
+javascript:(function() { var val = prompt('Enter log level (From -1 to 4)'); if (!val && val !== 0) { return; } document.cookie='_bvui_debug=logLevel:' + val; }());
+```
+
+Here are the values for log level. This bookmarklet will show you everything above the log level you enter as well (so if you enter `1`, you will see values for log level 1, 2, and 3).
+
+```
+  DEBUG: -1, // very noisy
+  LOG: 0,
+  INFO: 1,   // recommended
+  WARN: 2,
+  ERROR: 3,
+  OFF: 4,    // don't log anything
+```

package/lib/logger/index.js

@@ -0,0 +1,180 @@
+/*jshint expr:true */
+/*global console:false */
+
+/**
+ * @fileOverview Logger provides a wrapper around the console object. It should be used for creating
+ * messages that will be helpful for developers. Logger methods can safely be kept in the
+ * code -- that is, you don't need to remove them like you need to remove console.log statements.
+ *
+ * Logger should be used sparingly outside of framework files. When you use it, be thoughtful
+ * about the level of logging you choose. Most messages should be at the "debug" or "log" level, so
+ * developers can easily silence them. Messages at the info level will generally not be silenced
+ * during development, and messages at the warn and error level will almost never be silenced.
+ *
+ * Logger also provides the ability to make assertions. Assertions are useful when other
+ * developers may use your code in unpredictable ways. You can write an assertion so a fellow
+ * developer will know at a glance what your code expects, and so that they will get a useful
+ * error message if they violate those expectations.
+ *
+ * @type {Object}
+ */
+
+var global = require('../global');
+var ie = require('../ie')
+var cookie = require('../cookie');
+
+var logLevel = 4; // Default to OFF.
+
+/**
+ * Set the logLevel to whatever the _bvui_debug cookie has stored.
+ */
+var cookieObj = {};
+var debugCookie = cookie.read('_bvui_debug');
+if (debugCookie) {
+  var val;
+  var values = debugCookie.split(',');
+
+  for (var i = 0; i < values.length; i++) {
+    val = values[i].split(':');
+    cookieObj[ val[0] ] = val[1];
+  }
+}
+
+if (cookieObj.logLevel) {
+  logLevel = cookieObj.logLevel;
+}
+
+var Logger = {
+  // Assign these constants so we don't have to remember them.
+  DEBUG: -1, // very noisy
+  LOG: 0,
+  INFO: 1,   // recommended
+  WARN: 2,
+  ERROR: 3,
+  OFF: 4,    // don't log anything
+
+  getLogLevel: function () {
+    return logLevel;
+  },
+
+  /**
+   * Only sets the log level if there is no cookie or if passed a force param.
+   *
+   * @param {[type]} level logLevel
+   * @param {[type]} force arg to force setting level to the level arg
+   */
+  setLogLevel: function (level, force) {
+    logLevel = (!cookieObj.logLevel || force) ?
+      (level|| Logger.LOG) :
+      cookieObj.logLevel;
+    logger('log', [ 'Log level set to', logLevel ]);
+  },
+
+  debug: function () {
+    logLevel <= Logger.DEBUG && logger('log', arguments);
+  },
+
+  log: function () {
+    logLevel <= Logger.LOG && logger('log', arguments);
+  },
+
+  info: function () {
+    logLevel <= Logger.INFO && logger('info', arguments);
+  },
+
+  warn: function () {
+    logLevel <= Logger.WARN && logger('warn', arguments);
+  },
+
+  error: function () {
+    logLevel <= Logger.ERROR && logger('error', arguments);
+  },
+
+  count: function () {
+    logLevel < Logger.INFO && logger('count', arguments);
+  },
+
+  time: function () {
+    logLevel < Logger.WARN && logger('time', arguments);
+  },
+
+  timeEnd: function () {
+    logLevel < Logger.WARN && logger('timeEnd', arguments);
+  },
+
+  group: function (maxLevel) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    if (logLevel <= maxLevel) {
+      logger('group', args);
+      logger('time',  args);
+    }
+  },
+
+  groupEnd: function (maxLevel) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    if (logLevel <= maxLevel) {
+      logger('groupEnd', args);
+      logger('timeEnd',  args);
+    }
+  },
+
+  /**
+   * Assert that an expression is true, and throw the provided message if it is not.
+   *
+   * @param  {Expression} assertion
+   * @param  {String} message
+   */
+  assert: function (assertion, message) {
+    if (logLevel === Logger.OFF) {
+      return;
+    }
+
+    // If we want to assert something computationally expensive, we can pass a function
+    // as the sole argument to Logger.assert. The function should return an array with
+    // two items: the assertion, and the message.
+    if (typeof assertion === 'function') {
+      Logger.assert.apply(null, assertion());
+      return;
+    }
+
+    if (!assertion) {
+      throw new Error('Assertion failed: ' + message);
+    }
+  }
+};
+
+function logger (level, args) {
+  if (logLevel === Logger.OFF) {
+    return;
+  }
+  if (!global.console) {
+    return;
+  }
+
+  // If we want to log something that's computationally expensive, we can pass a
+  // function to a Logger method as its sole argument. The function should
+  // return the arguments to be logged; the function will only ever be executed
+  // in the development environment.
+  args = [].slice.call(args);
+
+  if (typeof args[0] === 'function') {
+    args = args[0]();
+  }
+
+  if (ie) {
+    global.console.log(args);
+    return;
+  }
+
+  try {
+    (global.console[level] || global.console.log).apply(global.console, args);
+  }
+  catch (e) {
+    // If we are unable to call, log then we cannot do anything but silently
+    // fail. In reality, you will either see your logs or you wont. And if you
+    // don't see the logs, there are only two cases: 1 - your logLevel is
+    // incorrect or 2 - logging is failing.
+  }
+}
+
+module.exports = Logger;

package/lib/messageFormat/README.md

@@ -0,0 +1,10 @@
+# messageFormat
+
+Uses `INTL.DisplayNames` and uses a polyfill from `https://cdn.polyfill.io/v3/polyfill.min.js?features=Intl.DisplayNames`
+
+# Usage 
+
+```javascript
+var messageFormat = require('bv-ui-core/lib/messageFormat');
+messageFormat.generateCountryFromLocale('en_US') // United States
+```

package/lib/messageFormat/index.js

@@ -0,0 +1,42 @@
+/**
+ *  @fileOverview
+ *  messageFormat provides utility functions to which use the INTL API which provides 
+ *  language sensitive string comparison, number formatting, and date and time formatting.
+ * 
+ *  messageFormat can have functions which are used in multiple places
+ *
+ *  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl
+ */
+
+
+var global = require('../global');
+/**
+ * Generates the country name associated with the given locale
+ * @param {string} locale The locale code (e.g., 'en_US')
+ * @returns {string} The name of the country associated with the locale, or an empty string if the locale is not supported by Intl.DisplayNames
+ */
+function generateCountryFromLocale (locale) {
+  if (!locale || locale.length === 0) {
+    return '';
+  }
+    
+  // Split the locale code into language and region components
+  try {
+    var localeArr = locale.split('_');
+    if (localeArr.length < 2) {
+      return '';
+    }
+  // Get the display name for the region (i.e., the country name)
+    var regionNames = new global.Intl.DisplayNames(localeArr[0], { type: 'region' });
+    var countryName = regionNames.of(localeArr[1]);
+  }
+  catch (error) {
+    return '';
+  }
+  // Return the country name, or an empty string if the region is not valid
+  return countryName 
+}
+
+module.exports = {
+  generateCountryFromLocale: generateCountryFromLocale
+}