bv-ui-core 0.1.1

package/lib/evented/index.js

@@ -0,0 +1,135 @@
+/* eslint-disable */
+/**
+ * @fileOverview
+ * asEvented v0.4.3 - an event emitter mixin which provides
+ * the observer pattern to JavaScript object.
+ *
+ * Copyright 2012, Michal Kuklis
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ *
+ **/
+/*
+ * Originally from https://github.com/mkuklis/asEvented
+ *
+ * Changelog:
+ * - removed UMD wrapper
+ * - do not export `bind` or `unbind`
+ */
+var ArrayProto = Array.prototype;
+var nativeIndexOf = ArrayProto.indexOf;
+var slice = ArrayProto.slice;
+
+/**
+ * By default, we should simply log the error to the console.
+ */
+function defaultErrorHandler(e) {
+  global.console.error(e);
+}
+
+/**
+ * Initialize a custom error handler for this instance, which may decide to log or even re-throw the error.
+ *
+ * @param {Function} fn - the custom callback to be invoked whenever an error is
+ *  detected as the result of a trigger event
+ */
+function setErrorHandler(fn) {
+  this.eventErrorHandler = fn;
+}
+
+function bind(event, fn) {
+  var i, part;
+  var events = this.events = this.events || {};
+  var parts = event.split(/\s+/);
+  var num = parts.length;
+
+  for (i = 0; i < num; i++) {
+    events[(part = parts[i])] = events[part] || [];
+    events[part].push(fn);
+  }
+  return this;
+}
+
+function one(event, fn) {
+  // [notice] The value of fn and fn1 is not equivalent in the case
+  // of the following in MSIE.
+  //
+  // var fn = function fn1 () { alert(fn === fn1) } ie.<9 false
+  var fnc = function () {
+    this.off(event, fnc);
+    fn.apply(this, slice.call(arguments));
+  };
+  this.on(event, fnc);
+  return this;
+}
+
+function unbind(event, fn) {
+  var eventName, i, index, num, parts;
+  var events = this.events;
+
+  if (!events) {
+    return;
+  }
+
+  parts = event.split(/\s+/);
+  for (i = 0, num = parts.length; i < num; i++) {
+    if ((eventName = parts[i]) in events !== false) {
+      index = (fn) ? _indexOf(events[eventName], fn) : 0;
+      if (index !== -1) {
+        events[eventName].splice(index, 1);
+      }
+    }
+  }
+  return this;
+}
+
+function trigger(event) {
+  var args, i;
+  var events = this.events;
+
+  if (!events || event in events === false) {
+    return;
+  }
+
+  args = slice.call(arguments, 1);
+  for (i = events[event].length - 1; i >= 0; i--) {
+    try {
+      events[event][i].apply(this, args);
+    }
+    catch (e) {
+      (this.eventErrorHandler || defaultErrorHandler).call(this, e, {
+        event: event,
+        data: args
+      });
+    }
+  }
+  return this;
+}
+
+// TODO: This is the same as the inArray method provided
+// by the utils module. This should be replaced in favor
+// of using that.
+function _indexOf(array, needle) {
+  var i, l;
+
+  if (nativeIndexOf && array.indexOf === nativeIndexOf) {
+    return array.indexOf(needle);
+  }
+
+  for (i = 0, l = array.length; i < l; i++) {
+    if (array[i] === needle) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+module.exports = function () {
+  this.on = bind;
+  this.off = unbind;
+  this.trigger = this.emit = trigger;
+  this.one = this.once = one;
+  this.setErrorHandler = setErrorHandler;
+
+  return this;
+};
+/* eslint-enable */

package/lib/getOriginalConstructor/README.md

@@ -0,0 +1,16 @@
+# getOriginalConstructor
+
+This file exposes a utility function to get a reset version of a primitive
+constructor, in the event that a site has overridden or polyfilled prototype
+methods in their own primitives, or used a utility like Prototype.js, which
+does that on its own. It returns a Promise that will be resolved with the
+original primitive constructor.
+
+## Usage
+```javascript
+var getOriginalConstructor = require('bv-ui-core/lib/getOriginalConstructor');
+
+getOriginalConstructor(Array).then(function (originalArray) {
+  originalArray.prototype.forEach(someNodeList, callback);
+});
+```

package/lib/getOriginalConstructor/index.js

@@ -0,0 +1,52 @@
+/**
+ *  @fileOverview
+ *  This file exposes a utility function to get a reset version of a primitive
+ *  constructor, in the event that a site has overridden or polyfilled
+ *  prototype methods in their own primitives, or used a utility like
+ *  Prototype.js, which does that on its own.
+ */
+
+var waitForBody = require('../waitForBody');
+
+var constructors = {};
+// eslint-disable-next-line no-useless-escape
+var constructorNameRegExp = /function\s+([^\(\s]+)/;
+
+var getOriginalConstructor = function getOriginalConstructor (constructor) {
+  return new Promise(function (resolve) {
+    waitForBody(function () {
+      var constructorName = constructor.name;
+      // IE11 doesn't have a constructor.name property, so just in case any other
+      // browsers also don't, use a simple regex to pull the constructor's name
+      // out of the .toString()'d function declaration, e.g. "function Array()"
+      if (!constructorName) {
+        constructorName = constructorNameRegExp.exec(constructor.toString())[1];
+      }
+
+      if (constructors[constructorName]) {
+        resolve(constructors[constructorName]);
+        return;
+      }
+      const tempIframe = document.createElement('iframe');
+      tempIframe.src = 'about:blank';
+      tempIframe.style.display = 'none';
+      tempIframe.style.position = 'absolute';
+      tempIframe.style.left = '-9999px';
+      tempIframe.height = '0';
+      tempIframe.width = '0';
+      tempIframe.tabIndex = '-1';
+      tempIframe.title = '';
+      tempIframe.setAttribute('aria-hidden', 'true');
+      tempIframe.setAttribute('role', 'presentation');
+      
+      document.body.appendChild(tempIframe);
+      
+      constructors[constructorName] = tempIframe.contentWindow[constructorName];
+      document.body.removeChild(tempIframe);
+      
+      resolve(constructors[constructorName]);
+    });
+  });
+};
+
+module.exports = getOriginalConstructor;

package/lib/global/README.md

@@ -0,0 +1,10 @@
+# Global
+
+Exposes the browser's `window` object for safe use elsewhere.
+
+## Usage
+```javascript
+var global = require('bv-ui-core/lib/global');
+
+var window = global;
+```

package/lib/global/index.js

@@ -0,0 +1,48 @@
+/**
+ *  @fileOverview Provides a reference to the global object
+ *  the below solution works in ES3+ environment and doesn't violates CSP in Chrome apps 
+ *  see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis
+ */
+'use strict'; /* eslint strict:0 */
+
+var getGlobal = function () {
+  var globalObj = (function () {
+    if (typeof globalThis !== 'undefined') { return globalThis; }
+    if (typeof window !== 'undefined') { return window; }
+    if (typeof self !== 'undefined') { return self; }
+    if (typeof global !== 'undefined') { return global; }
+    throw new Error('unable to locate global object');
+  })()
+  /*
+    The below code was added in case there is pollution in global namespace
+    windows object during transpilation with __esModule being set. Below code would support
+    global import in all bundle use cases
+  */
+  if (globalObj && globalObj.__esModule) {
+    const proxyGlobal = new Proxy(globalObj, {
+      get: function (target, prop) {
+        if (prop === 'default') {
+          return target
+        }
+
+        var value = target[prop]
+        // Native/branded methods (e.g. getComputedStyle) throw "Illegal invocation"
+        // if called with the Proxy as `this` instead of the real target.
+        if (typeof value === 'function') {
+          return value.bind(target)
+        }
+
+        return value
+      },
+
+      set: function (target, prop, value) {
+        target[prop] = value
+        return true
+      },
+    })
+    return proxyGlobal
+  }
+  return globalObj
+};
+
+module.exports = getGlobal();

package/lib/ie/README.md

@@ -0,0 +1,13 @@
+# ie
+
+The ie module provides the version of IE in which the scout is running, if the
+browser is IE and the version is less than or equal to 9. In other cases, the
+value provided by the module is false.
+
+```js
+var ie = require('bv-ui-core/lib/ie');
+
+if (!ie) {
+  // Thank goodness.
+}
+```

package/lib/ie/index.js

@@ -0,0 +1,25 @@
+/* eslint no-sequences: 0 */
+/**
+ * @fileOverview
+ * A short snippet for detecting versions of IE in JavaScript
+ * without resorting to user-agent sniffing. Will only work for IE >=5 and <=9
+ * since IE10 dropped support for conditional comments. When ie is undefined
+ * it means it's either IE10+ or not an IE browser.
+ */
+
+var doc = require('../global').document;
+
+module.exports = (function () {
+  var ie = (function (v, div, undef) {
+    var all = div.getElementsByTagName('i');
+
+    while (
+      div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->', all[0]
+    ) {
+      // Empty.
+    }
+    return v > 4 ? v : undef;
+  })(3, doc.createElement('div'));
+
+  return ie;
+})();

package/lib/loader/README.md

@@ -0,0 +1,73 @@
+# loader
+
+The loader module provides the following methods:
+
+- `loadScript(url, [options], [callback])`: Loads the script at the provided
+  URL in a non-blocking manner, and executes a Node-style callback (if
+  provided) when the script is loaded or fails to load. A
+  `timeout` value in milliseconds can be provided via the `options` argument.
+- `loadStyleSheet(url, [options], [callback])`: Loads the CSS at the provided
+  URL in a non-blocking manner, and executes a Node-style callback (if
+  provided) when the CSS is loaded or fails to load. Also returns a promise
+  that will be resolved if the CSS loads, and rejected if it does not. A
+  `timeout` value in milliseconds can be provided via the `options` argument.
+
+```js
+var loader = require('bv-ui-core/lib/loader');
+
+loader.loadScript('/scripts/main.js', function (err) {
+  if (!err) {
+    console.log('it worked');
+  }
+});
+```
+
+Note: Failure to load is *not* reliably detected in older versions of IE. For
+both `loadScript` and `loadStyleSheet`, the callback will not be executed on
+failure in old IE.
+
+### loadScript options
+
+- **attributes**: an object containing key/value pairs to be used as
+attributes on the created `<script>` element.
+- **timeout**: the time in milliseconds before the loading should be
+considered failed. Defaults to 10000ms.
+- **forceLoad**: a boolean value as to whether the script should
+attempt to be loaded if an earlier attempt was made. Defaults to false.
+- **namespaceName**: a string containing the name of the namespace to check
+if the script has been previously loaded and store the loadedUrls hash
+
+### loadStyleSheet options
+
+- **attributes**: an object containing key/value pairs to be used as
+attributes on the created `<link>` element.
+- **injectionNode**: a DOM node into which the `<link>` element should be
+placed. The default insertion point is after the first `<script>` element on the page.
+- **timeout**: the time in milliseconds before the loading should be
+considered failed. Defaults to 10000ms.
+- **forceLoad**: a boolean value as to whether the stylesheet should
+attempt to be loaded if an earlier attempt was made. Defaults to false.
+- **namespaceName**: a string containing the name of the namespace to check
+if the stylesheet has been previously loaded and store the loadedUrls hash
+
+### loader timeout
+
+The loader module provides an extensible timeout that will invoke the provided
+callback with an error. In certain remote testing environments, the default
+timeout may not be sufficient for an initial page load. If you experience
+timeout errors when using the loader module you should experiment with raising
+this timeout using the provided `option.timeout`.
+
+```js
+var loader = require('bv-ui-core/lib/loader');
+
+var options =  {
+  timeout : 30000
+}
+
+loader.loadScript('/scripts/main.js', options, function (err, cb) {
+  if (err) {
+    console.log('We may have timed out :(');
+  }
+});
+```