bv-ui-core 0.1.1

package/lib/cookieConsent/index.js

@@ -0,0 +1,227 @@
+var cookieConsent = (function () {
+  var init = false;
+  var consentDisabled = true;
+  var store = {};
+  var subscribers = {};
+  var events = ['add', 'enable', 'disable', 'change'];
+  var storeCallbacks = {};
+
+
+  /**
+   * _publish: Calls subscriber callbacks
+   * @param {String} consentKey Consent key
+   * @param {String} eventName Event name
+   * @param {Boolean} data Consent value
+   */
+  function _publish (consentKey, eventName, data) {
+    if (subscribers[consentKey] && subscribers[consentKey][eventName]) {
+      Object.values(subscribers[consentKey][eventName]).forEach(function (callback) {
+        callback(data);
+      })
+    }
+  }
+
+  /**
+   * _publishStore: calls Callbacks with the store object passed
+   */
+
+  function _publishStore () {
+    if (Object.values(storeCallbacks).length > 0) {
+      Object.values(storeCallbacks).forEach(function (callback) {
+        callback(Object.assign({}, store));
+      })
+    }
+  }
+  /**
+   * _set: Set store data
+   * @param {String} consentKey Consent key
+   * @param {String} consentValue Consent value
+   */
+  function _set (consentKey, consentValue) {
+    if (typeof consentValue !== 'boolean') {
+      throw new TypeError('cookieConsent (setConsent): consent values should be of type boolean. Check value for ' + consentKey + '.');
+    }
+
+    var oldValue = store[consentKey];
+
+    if (oldValue !== consentValue) {
+      store[consentKey] = consentValue;
+
+      if (oldValue === undefined) {
+        _publish(consentKey, 'add', consentValue);
+      }
+      if (oldValue === true) {
+        _publish(consentKey, 'disable', consentValue);
+        _publish(consentKey, 'change', consentValue);
+      }
+      else if (oldValue === false) {
+        _publish(consentKey, 'enable', consentValue);
+        _publish(consentKey, 'change', consentValue);
+      }
+      else {
+        _publish(consentKey, 'change', consentValue);
+      }
+    }
+  }
+  /**
+   * _unsubscribe: Unsubscribe subscribers
+   */
+  function _unsubscribe () {
+    if (subscribers[this.consentKey] && subscribers[this.consentKey][this.eventName]) {
+      delete subscribers[this.consentKey][this.eventName][this.key];
+    }
+  }
+
+  /**
+   * _unsubscribeStore: Unsubscribes subscribers from the consent store 
+   */
+  function _unsubscribeStore () {
+    if (storeCallbacks[this.key]) {
+      delete storeCallbacks[this.key];
+    }
+  }
+  /**
+   * Get consent disabled
+   * @returns Boolean
+   */
+  function getConsentDisabled () {
+    return consentDisabled
+  }
+  /**
+   * initConsent: Initialize the consent store
+   * @param {Object} consent Consent object
+   * @param {Boolean} disable Disable consent
+   * @returns Boolean
+   */
+  function initConsent (consent, disable) {
+    if (!init) {
+      consentDisabled = !!disable;
+
+      if (consentDisabled) {
+        init = true;
+        return true;
+      }
+
+      if (!(consent && !Array.isArray(consent) && typeof consent === 'object')) {
+        throw new TypeError('cookieConsent (init): consent should be an object.');
+      }
+
+      var keys = Object.keys(consent);
+
+      for (var i = 0; i < keys.length; i++) {
+        if (typeof consent[keys[i]] !== 'boolean') {
+          throw new TypeError('cookieConsent (init): consent values for ' + keys[i] + ' should be of type boolean.');
+        }
+      }
+
+      store = Object.assign({}, consent);
+      init = true;
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * getConsent: Get consent value from store
+   * @param {String} consentKey Consent key
+   * @returns Boolean or Undefined
+   */
+  function getConsent (consentKey) {
+    if (consentDisabled) {
+      return true;
+    }
+
+    return store[consentKey];
+  }
+  /**
+   * setConsent: Set consent values in the store
+   * @param {Object} consent Consent object
+   * @returns Boolean
+   */
+  function setConsent (consent) {
+    if (init && !consentDisabled) {
+      if (!(consent && !Array.isArray(consent) && typeof consent === 'object')) {
+        throw new TypeError('cookieConsent (setConsent): consent should be an object.')
+      }
+      var store 
+      var keys = Object.keys(consent);
+      for (var i = 0; i < keys.length; i++) {
+        _set(keys[i], consent[keys[i]]);
+      }
+      var storeCopy=Object.assign({},store)
+      if (JSON.stringify(storeCopy)!==JSON.stringify(store)) {
+        _publishStore()
+      }
+      return true;
+    }
+
+    return false;
+  }
+  /**
+   * subscribe: Subscribe to store events
+   * @param {String} consentKey Consent key
+   * @param {String} eventName Event name
+   * @param {Function} callback Event callback
+   * @returns Object: Contains unsubscribe method
+   */
+  function subscribe (consentKey, eventName, callback) {
+    if (typeof consentKey !== 'string') {
+      throw new TypeError('cookieConsent (subscribe): consent key should be of type string.');
+    }
+
+    if (typeof eventName !== 'string') {
+      throw new TypeError('cookieConsent (subscribe): event name should be of type string.');
+    }
+
+    if (!events.includes(eventName)) {
+      throw new TypeError('cookieConsent (subscribe): event name should be one of ' + events.join(', ') + '.');
+    }
+
+    if (typeof callback !== 'function') {
+      throw new TypeError('cookieConsent (subscribe): callback should be a function.');
+    }
+
+    if (!subscribers[consentKey]) {
+      subscribers[consentKey] = {};
+    }
+
+    if (!subscribers[consentKey][eventName]) {
+      subscribers[consentKey][eventName] = {};
+    }
+    var key = Math.random().toString(36).substr(2, 5);
+
+    subscribers[consentKey][eventName][key] = callback
+
+    return {
+      unsubscribe: _unsubscribe.bind({
+        consentKey: consentKey,
+        eventName: eventName,
+        key: key
+      })
+    };
+  }
+
+  function subscribeToConsentStore (callback) {
+    if (typeof callback !== 'function') {
+      throw new TypeError('cookieConsent (subscribeToConsentStore): callback should be a function.');
+    }
+
+    var key = Math.random().toString(36).substr(2, 5);
+    storeCallbacks[key] = callback;
+
+    return {
+      unsubscribe: _unsubscribeStore.bind({ key: key })
+    }
+  }
+
+  return {
+    initConsent: initConsent,
+    getConsent: getConsent,
+    getConsentDisabled: getConsentDisabled,
+    setConsent: setConsent,
+    subscribe: subscribe,
+    subscribeToConsentStore: subscribeToConsentStore
+  };
+})();
+
+module.exports = cookieConsent;

package/lib/cssLoadChecker/README.md

@@ -0,0 +1,19 @@
+# CSS Load Checker
+
+This module provides a means of checking if a CSS file has been loaded already or not. It does this by adding a test div to the page and checking the computed styles of it for the `display: none` style.
+
+```js
+var cssLoadChecker = require('bv-ui-core/lib/cssLoadChecker');
+
+if (cssLoadChecker.isCssLoaded('bv-verify-css-loaded')) {
+  // do stuff if loaded
+}
+else {
+  // do stuff if not loaded (like load it)
+  loader.loadStyleSheet(namespace.cssUrl, callback);
+}
+```
+
+The following methods are provided:
+
+- `isCssLoaded(className)`: Loads a test div onto the page with the given class name and checks for the style `display: none`. If this is set, then the CSS file is assumed to be present so it returns true. Otherwise, it returns false. The test div is removed before this function finishes executing.

package/lib/cssLoadChecker/index.js

@@ -0,0 +1,72 @@
+/**
+ * @fileOverview
+ * Provides functions for checking if a stylesheet has been loaded previously
+ */
+
+// Imports
+var global = require('../global');
+var body = require('../body');
+
+/**
+ * Function to add the test div to the page
+ *
+ * @param {string} className - The class name used to check if the css file has loaded yet
+ *  (does not include the '.' out front, just the name)
+ * @return {object} The element that was just created for the purposes of
+ *  testing whether the CSS has loaded or not
+ */
+var _loadTestDiv = function (className) {
+  var testDiv;
+
+  testDiv = global.document.createElement('div');
+  testDiv.style.height = '0px';
+  testDiv.style.width = '0px';
+  testDiv.style.border = '0px';
+  testDiv.className = className;
+  body().appendChild(testDiv);
+
+  return testDiv;
+};
+
+/**
+ * Function to remove the test div from the page
+ *
+ * @param {object} testDiv - The element that was created for the purposes of
+ *  testing whether the CSS has loaded or not
+ */
+var _cleanupTestDiv = function (testDiv) {
+  testDiv.parentNode.removeChild(testDiv);
+};
+
+module.exports = {
+
+  /**
+   * Check the test div to see if the styles have loaded
+   *
+   * @param {string} className - The class name used to check if the css file has loaded yet
+   *  (does not include the '.' out front, just the name)
+   * @return {boolean} True or false as to whether the style sheet has been loaded.
+   */
+  isCssLoaded: function (className) {
+    var testDiv = _loadTestDiv(className);
+    var displayVal;
+    var result = false;
+
+    // add support for IE8
+    if (!global.getComputedStyle) {
+      displayVal = testDiv.currentStyle['display'];
+    }
+    else {
+      var computedStyles = global.getComputedStyle(testDiv);
+      displayVal = computedStyles.getPropertyValue('display');
+    }
+
+    if (displayVal === 'none') {
+      result = true;
+    }
+
+    _cleanupTestDiv(testDiv);
+    return result;
+  }
+
+};

package/lib/date.now/README.md

@@ -0,0 +1,11 @@
+# Date.now
+
+Uses `Date.now` when available and falls back to `new Date().getTime()` when
+needed to get the number of milliseconds elapsed since 1 Jan 1970 00:00:00 UTC.
+
+## Usage
+```javascript
+var date = require('date.now');
+
+var now = date.now();
+```

package/lib/date.now/index.js

@@ -0,0 +1,40 @@
+/**
+ *  @fileOverview
+ *  Provides a unified interface for getting the number of
+ *  milliseconds elapsed since 1 Jan 1970
+ *
+ *  https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now
+ */
+
+// Imports
+var global = require('../global');
+
+// Cache references for speed and to guard against shenanigans
+var nativeDate = global.Date;
+var nativeNow = nativeDate && nativeDate.now;
+
+// Is Date.now natively supported?
+var isNativeSupported = (typeof nativeNow === 'function');
+
+/**
+ *  Native Implementation
+ *  Uses the natively-supported Date.now
+ */
+function nativeImplementation () {
+  return nativeNow.call(nativeDate);
+}
+
+/**
+ *  Polyfill Implementation
+ *  Provides similar functionality by using new Date().getTime()
+ */
+function polyfillImplementation () {
+  return new nativeDate().getTime(); /*eslint new-cap:0*/
+}
+
+module.exports = {
+  now: function () {
+    var func = (isNativeSupported) ? nativeImplementation : polyfillImplementation;
+    return func();
+  }
+};

package/lib/domainPolice/README.md

@@ -0,0 +1,66 @@
+# domainPolice
+
+The `domainPolice` module provides a function that takes a hostname and an array of
+objects representing a known whitelist of domains, and returns an object with a
+simple API, representing the state of that URL in the whitelist.
+
+## Module arguments
+
+ - `hostname`: The particular hostname to be validated as a string. Ports and protocols are not validated and should not be supplied as part of this. Optimally, this should be provided from `window.location.hostname` in the browser.
+ - `allowedDomains`: An array of objects representing whitelisted arrays.
+
+## Usage
+
+```javascript
+var domainPolice = require('bv-ui-core/lib/domainPolice');
+
+var allowedDomains = [
+  {
+    domain: '.bazaarvoice.com',
+    thirdPartyCookieEnabled: true
+  },
+  {
+    domain: '.localhost',
+    thirdPartyCookieEnabled: false,
+    commentsEnabled: true,
+  },
+  {
+    domain: 'no-prefixing-dot.foo.com',
+    commentsEnabled: true
+  }
+];
+
+var bvCop = domainPolice(allowedDomains, 'www.bazaarvoice.com');
+bvCop.isValid; // => true
+bvCop.get('domain'); // => '.bazaarvoice.com'
+bvCop.get('thirdPartyCookieEnabled'); // => true
+bvCop.get('commentsEnabled'); // => undefined
+
+var nopeCop = domainPolice(allowedDomains, 'ww.w.foo.com');
+nopeCop.isValid; // => false
+nopeCop.get('anything'); // => undefined
+```
+
+### `allowedDomains` format
+
+`allowedDomains` is an array of objects, and each object is expected to have a
+`domain` property. It may also contain any other arbitrary properties as desired
+for later lookup.
+
+Prefixing `.` on the `domain` will allow it to match all subdomains as well.
+URL hosts which include `www.` will be allowed with domain name match.
+
+Given the above example, the following domains are all valid:
+
+- `bazaarvoice.com`
+- `subdomain.bazaarvoice.com`
+- `localhost`
+- `www-stg.localhost`
+- `no-prefixing-dot.foo.com`
+- `www.no-prefixing-dot.foo.com`
+
+Domains that would not be allowed:
+
+- `foo.com`
+- `something.foo.com`
+- `bazaarvoice.co.jp`

package/lib/domainPolice/index.js

@@ -0,0 +1,95 @@
+/**
+ * @fileOverview
+ * The DomainPolice module is used to provide validation that content is only
+ * being loaded on authorized domains.
+ */
+
+/**
+ * Returns true if the hostname is an exact match for a specific domain or a
+ * suffix match for a wildcard domain (domain starts with a '.').
+ *
+ * @param  {String} domain Domain to check.
+ * @param  {String} hostname Hostname to check against.
+ * @return {Boolean}
+ */
+function domainMatches (domain, hostname) {
+  if (domain && (domain.charAt(0) === '.') && hostname) {
+    // domainMatches('.domain.com', 'sub.domain.com') and
+    // domainMatches('.sub.domain.com', 'sub.domain.com') are both true.
+    var index = ('.' + hostname).lastIndexOf(domain);
+    return index >= 0 && index === (1 + hostname.length - domain.length);
+  }
+
+  return hostname === domain || hostname === ('www.' + domain);
+}
+
+/**
+ * Returns the matching domain object if the hostname of the specified URL
+ * matches one of the specified domains.
+ *
+ * @param  {Array}  domains The set of domain objects to check the URL against
+ * @param  {String} hostname The hostname to check
+ * @return {Object} The matching domain object from the array of provided domains
+ */
+function allowedDomain (domains, hostname) {
+  var matchedDomain;
+
+  for (var i = 0; i < domains.length; i++) {
+    if (domainMatches(domains[i].domain, hostname)) {
+      matchedDomain = domains[i];
+
+      return matchedDomain;
+    }
+  }
+
+  // No match found, explicitly returning undefined
+  return undefined;
+}
+
+/**
+ * Returns an object that represents a found domain, including the ability to get various attributes off of the associated object from the domains array.
+ *
+ * @param  {Array}  domains The set of domain objects to check the URL against
+ * @param  {String} hostname The hostname to be checked against. Preferably sourced by using window.location.hostname.
+ * @return {Object} An object representing the state of the matched domain
+ */
+function domainPolice (domains, hostname) {
+  var domainState = {};
+  var domain = {
+    isValid: false,
+    get: function (key) {
+      return domainState[key];
+    }
+  };
+
+  var domainObject = allowedDomain(domains, hostname);
+
+  // If we have a matching domain
+  if (domainObject) {
+    domain.isValid = true;
+
+    // Manually copying keys, because I can't safely use Object.assign
+    // or the npm object-assign module, or even lodash.assign/lodash.extend,
+    // as they're assuming ES5 environments.
+    //
+    // TODO: Once we drop IE11, simplify.
+    for (var key in domainObject) {
+      if (domainObject.hasOwnProperty(key)) {
+        domainState[key] = domainObject[key];
+      }
+    }
+
+    // Special case: If the domain is a valid IPv4 address,
+    // remove the leading period.
+    // The return value here should be used when setting a cookie, and IPv4
+    // addresses with a prefixed period do not work for cookie setting like
+    // they do for domains.
+    if (domainState.domain.match(/^(\.\d+){4}$/)) {
+      domainState.domain = domainState.domain.substr(1);
+    }
+  }
+
+  return domain;
+}
+
+module.exports = domainPolice;

package/lib/evented/README.md

@@ -0,0 +1,42 @@
+# evented
+
+Based on [asEvented][1], the evented module provides a function that can be
+called on a constructor in order to make instances act as event emitters.
+
+```js
+var evented = require('bv-ui-core/lib/evented');
+
+function Model(config) {
+  this.config = config;
+};
+
+evented.call(Model.prototype);
+```
+
+An event emitter provides the following methods:
+
+- `on(event, fn)`
+- `off(event, fn)`
+- `one(event, fn)`
+- `once(event, fn)`
+- `trigger(event, *data)`
+
+By default, any errors thrown from an event listener are caught and simply logged to the console.
+An alternate behavior can be specified by providing an event handler:
+
+```js
+var model = new Model({});
+
+model.setErrorHandler(function(error, trigger) {
+  // The following parameters are available to this function:
+  //  - error : the value that was thrown, typically an instance of Error
+  //  - trigger.event : the name of the event passed to trigger()
+  //  - trigger.data : an array containing the additional arguments passed to trigger()
+  //  - this : the instance on which trigger() was invoked
+});
+
+// If you prefer for errors to be thrown from trigger(), then use:
+model.setErrorHandler(function(error) { throw error; });
+```
+
+[1]: https://github.com/mkuklis/asEvented