aacinfo-theme 0.2.0 → 2.0.1

data/_sass/what-input/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "what-input",
+  "version": "4.0.6",
+  "description": "A global utility for tracking the current input method (mouse, keyboard or touch).",
+  "main": "dist/what-input.js",
+  "repository": {
+    "url": "https://github.com/ten1seven/what-input.git",
+    "type": "git"
+  },
+  "keywords": [
+    "accessibility",
+    "a11y",
+    "input",
+    "javascript"
+  ],
+  "author": "Jeremy Fields <jeremy.fields@viget.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ten1seven/what-input/issues"
+  },
+  "scripts": {
+    "start": "gulp"
+  },
+  "homepage": "https://github.com/ten1seven/what-input",
+  "devDependencies": {
+    "browser-sync": "2.11.1",
+    "del": "2.2.0",
+    "gulp": "3.9.1",
+    "gulp-concat": "2.6.0",
+    "gulp-header": "1.7.1",
+    "gulp-notify": "2.2.0",
+    "gulp-plumber": "1.1.0",
+    "gulp-rename": "1.2.2",
+    "gulp-uglify": "^2.0.0",
+    "run-sequence": "1.1.5",
+    "webpack-stream": "3.2.0"
+  }
+}

data/_sass/what-input/src/polyfills/ie8/EventListener.js

@@ -0,0 +1,150 @@
+// EventListener | CC0 | github.com/jonathantneal/EventListener
+
+this.Element && Element.prototype.attachEvent && !Element.prototype.addEventListener && (function () {
+	function addToPrototype(name, method) {
+		Window.prototype[name] = HTMLDocument.prototype[name] = Element.prototype[name] = method;
+	}
+
+	// add
+	addToPrototype("addEventListener", function (type, listener) {
+		var
+		target = this,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		// if no events exist, attach the listener
+		if (!typeListeners.length) {
+			target.attachEvent("on" + type, typeListeners.event = function (event) {
+				var documentElement = target.document && target.document.documentElement || target.documentElement || { scrollLeft: 0, scrollTop: 0 };
+
+				// polyfill w3c properties and methods
+				event.currentTarget = target;
+				event.pageX = event.clientX + documentElement.scrollLeft;
+				event.pageY = event.clientY + documentElement.scrollTop;
+				event.preventDefault = function () { event.returnValue = false };
+				event.relatedTarget = event.fromElement || null;
+				event.stopImmediatePropagation = function () { immediatePropagation = false; event.cancelBubble = true };
+				event.stopPropagation = function () { event.cancelBubble = true };
+				event.target = event.srcElement || target;
+				event.timeStamp = +new Date;
+
+				var plainEvt = {};
+				for (var i in event) {
+					plainEvt[i] = event[i];
+				}
+
+				// create an cached list of the master events list (to protect this loop from breaking when an event is removed)
+				for (var i = 0, typeListenersCache = [].concat(typeListeners), typeListenerCache, immediatePropagation = true; immediatePropagation && (typeListenerCache = typeListenersCache[i]); ++i) {
+					// check to see if the cached event still exists in the master events list
+					for (var ii = 0, typeListener; typeListener = typeListeners[ii]; ++ii) {
+						if (typeListener == typeListenerCache) {
+							typeListener.call(target, plainEvt);
+
+							break;
+						}
+					}
+				}
+			});
+		}
+
+		// add the event to the master event list
+		typeListeners.push(listener);
+	});
+
+	// remove
+	addToPrototype("removeEventListener", function (type, listener) {
+		var
+		target = this,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		// remove the newest matching event from the master event list
+		for (var i = typeListeners.length - 1, typeListener; typeListener = typeListeners[i]; --i) {
+			if (typeListener == listener) {
+				typeListeners.splice(i, 1);
+
+				break;
+			}
+		}
+
+		// if no events exist, detach the listener
+		if (!typeListeners.length && typeListeners.event) {
+			target.detachEvent("on" + type, typeListeners.event);
+		}
+	});
+
+	// dispatch
+	addToPrototype("dispatchEvent", function (eventObject) {
+		var
+		target = this,
+		type = eventObject.type,
+		listeners = target.addEventListener.listeners = target.addEventListener.listeners || {},
+		typeListeners = listeners[type] = listeners[type] || [];
+
+		try {
+			return target.fireEvent("on" + type, eventObject);
+		} catch (error) {
+			if (typeListeners.event) {
+				typeListeners.event(eventObject);
+			}
+
+			return;
+		}
+	});
+
+	// CustomEvent
+	Object.defineProperty(Window.prototype, "CustomEvent", {
+		get: function () {
+			var self = this;
+
+			return function CustomEvent(type, eventInitDict) {
+				var event = self.document.createEventObject(), key;
+
+				event.type = type;
+				for (key in eventInitDict) {
+					if (key == 'cancelable'){
+						event.returnValue = !eventInitDict.cancelable;
+					} else if (key == 'bubbles'){
+						event.cancelBubble = !eventInitDict.bubbles;
+					} else if (key == 'detail'){
+						event.detail = eventInitDict.detail;
+					}
+				}
+				return event;
+			};
+		}
+	});
+
+	// ready
+	function ready(event) {
+		if (ready.interval && document.body) {
+			ready.interval = clearInterval(ready.interval);
+
+			document.dispatchEvent(new CustomEvent("DOMContentLoaded"));
+		}
+	}
+
+	ready.interval = setInterval(ready, 1);
+
+	window.addEventListener("load", ready);
+})();
+
+(!this.CustomEvent || typeof this.CustomEvent === "object") && (function() {
+	// CustomEvent for browsers which don't natively support the Constructor method
+	this.CustomEvent = function CustomEvent(type, eventInitDict) {
+		var event;
+		eventInitDict = eventInitDict || {bubbles: false, cancelable: false, detail: undefined};
+
+		try {
+			event = document.createEvent('CustomEvent');
+			event.initCustomEvent(type, eventInitDict.bubbles, eventInitDict.cancelable, eventInitDict.detail);
+		} catch (error) {
+			// for browsers which don't support CustomEvent at all, we use a regular event instead
+			event = document.createEvent('Event');
+			event.initEvent(type, eventInitDict.bubbles, eventInitDict.cancelable);
+			event.detail = eventInitDict.detail;
+		}
+
+		return event;
+	};
+})();

data/_sass/what-input/src/polyfills/ie8/indexOf.js

@@ -0,0 +1,65 @@
+// Production steps of ECMA-262, Edition 5, 15.4.4.14
+// Reference: http://es5.github.io/#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(searchElement, fromIndex) {
+
+    var k;
+
+    // 1. Let O be the result of calling ToObject passing
+    //    the this value as the argument.
+    if (this == null) {
+      throw new TypeError('"this" is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get
+    //    internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length >>> 0;
+
+    // 4. If len is 0, return -1.
+    if (len === 0) {
+      return -1;
+    }
+
+    // 5. If argument fromIndex was passed let n be
+    //    ToInteger(fromIndex); else let n be 0.
+    var n = +fromIndex || 0;
+
+    if (Math.abs(n) === Infinity) {
+      n = 0;
+    }
+
+    // 6. If n >= len, return -1.
+    if (n >= len) {
+      return -1;
+    }
+
+    // 7. If n >= 0, then Let k be n.
+    // 8. Else, n<0, Let k be len - abs(n).
+    //    If k is less than 0, then let k be 0.
+    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);
+
+    // 9. Repeat, while k < len
+    while (k < len) {
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the
+      //    HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      //    i.  Let elementK be the result of calling the Get
+      //        internal method of O with the argument ToString(k).
+      //   ii.  Let same be the result of applying the
+      //        Strict Equality Comparison Algorithm to
+      //        searchElement and elementK.
+      //  iii.  If same is true, return k.
+      if (k in O && O[k] === searchElement) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}

data/_sass/what-input/src/what-input.js

@@ -0,0 +1,269 @@
+module.exports = (function() {
+
+  /*
+    ---------------
+    Variables
+    ---------------
+  */
+
+  // cache document.documentElement
+  var docElem = document.documentElement;
+
+  // last used input type
+  var currentInput = 'initial';
+
+  // last used input intent
+  var currentIntent = null;
+
+  // form input types
+  var formInputs = [
+    'input',
+    'select',
+    'textarea'
+  ];
+
+  // list of modifier keys commonly used with the mouse and
+  // can be safely ignored to prevent false keyboard detection
+  var ignoreMap = [
+    16, // shift
+    17, // control
+    18, // alt
+    91, // Windows key / left Apple cmd
+    93  // Windows menu / right Apple cmd
+  ];
+
+  // mapping of events to input types
+  var inputMap = {
+    'keyup': 'keyboard',
+    'mousedown': 'mouse',
+    'mousemove': 'mouse',
+    'MSPointerDown': 'pointer',
+    'MSPointerMove': 'pointer',
+    'pointerdown': 'pointer',
+    'pointermove': 'pointer',
+    'touchstart': 'touch'
+  };
+
+  // array of all used input types
+  var inputTypes = [];
+
+  // boolean: true if touch buffer timer is running
+  var isBuffering = false;
+
+  // map of IE 10 pointer events
+  var pointerMap = {
+    2: 'touch',
+    3: 'touch', // treat pen like touch
+    4: 'mouse'
+  };
+
+  // touch buffer timer
+  var touchTimer = null;
+
+
+  /*
+    ---------------
+    Set up
+    ---------------
+  */
+
+  var setUp = function() {
+
+    // add correct mouse wheel event mapping to `inputMap`
+    inputMap[detectWheel()] = 'mouse';
+
+    addListeners();
+    setInput();
+  };
+
+
+  /*
+    ---------------
+    Events
+    ---------------
+  */
+
+  var addListeners = function() {
+
+    // `pointermove`, `MSPointerMove`, `mousemove` and mouse wheel event binding
+    // can only demonstrate potential, but not actual, interaction
+    // and are treated separately
+
+    // pointer events (mouse, pen, touch)
+    if (window.PointerEvent) {
+      docElem.addEventListener('pointerdown', updateInput);
+      docElem.addEventListener('pointermove', setIntent);
+    } else if (window.MSPointerEvent) {
+      docElem.addEventListener('MSPointerDown', updateInput);
+      docElem.addEventListener('MSPointerMove', setIntent);
+    } else {
+
+      // mouse events
+      docElem.addEventListener('mousedown', updateInput);
+      docElem.addEventListener('mousemove', setIntent);
+
+      // touch events
+      if ('ontouchstart' in window) {
+        docElem.addEventListener('touchstart', touchBuffer);
+      }
+    }
+
+    // mouse wheel
+    docElem.addEventListener(detectWheel(), setIntent);
+
+    // keyboard events
+    docElem.addEventListener('keydown', updateInput);
+    docElem.addEventListener('keyup', updateInput);
+  };
+
+  // checks conditions before updating new input
+  var updateInput = function(event) {
+
+    // only execute if the touch buffer timer isn't running
+    if (!isBuffering) {
+      var eventKey = event.which;
+      var value = inputMap[event.type];
+      if (value === 'pointer') value = pointerType(event);
+
+      if (
+        currentInput !== value ||
+        currentIntent !== value
+      ) {
+
+        var activeElem = document.activeElement;
+        var activeInput = (
+          activeElem &&
+          activeElem.nodeName &&
+          formInputs.indexOf(activeElem.nodeName.toLowerCase()) === -1
+        ) ? true : false;
+
+        if (
+          value === 'touch' ||
+
+          // ignore mouse modifier keys
+          (value === 'mouse' && ignoreMap.indexOf(eventKey) === -1) ||
+
+          // don't switch if the current element is a form input
+          (value === 'keyboard' && activeInput)
+        ) {
+
+          // set the current and catch-all variable
+          currentInput = currentIntent = value;
+
+          setInput();
+        }
+      }
+    }
+  };
+
+  // updates the doc and `inputTypes` array with new input
+  var setInput = function() {
+    docElem.setAttribute('data-whatinput', currentInput);
+    docElem.setAttribute('data-whatintent', currentInput);
+
+    if (inputTypes.indexOf(currentInput) === -1) {
+      inputTypes.push(currentInput);
+      docElem.className += ' whatinput-types-' + currentInput;
+    }
+  };
+
+  // updates input intent for `mousemove` and `pointermove`
+  var setIntent = function(event) {
+
+    // only execute if the touch buffer timer isn't running
+    if (!isBuffering) {
+      var value = inputMap[event.type];
+      if (value === 'pointer') value = pointerType(event);
+
+      if (currentIntent !== value) {
+        currentIntent = value;
+
+        docElem.setAttribute('data-whatintent', currentIntent);
+      }
+    }
+  };
+
+  // buffers touch events because they frequently also fire mouse events
+  var touchBuffer = function(event) {
+
+    // clear the timer if it happens to be running
+    window.clearTimeout(touchTimer);
+
+    // set the current input
+    updateInput(event);
+
+    // set the isBuffering to `true`
+    isBuffering = true;
+
+    // run the timer
+    touchTimer = window.setTimeout(function() {
+
+      // if the timer runs out, set isBuffering back to `false`
+      isBuffering = false;
+    }, 200);
+  };
+
+
+  /*
+    ---------------
+    Utilities
+    ---------------
+  */
+
+  var pointerType = function(event) {
+   if (typeof event.pointerType === 'number') {
+      return pointerMap[event.pointerType];
+   } else {
+      return (event.pointerType === 'pen') ? 'touch' : event.pointerType; // treat pen like touch
+   }
+  };
+
+  // detect version of mouse wheel event to use
+  // via https://developer.mozilla.org/en-US/docs/Web/Events/wheel
+  var detectWheel = function() {
+    return 'onwheel' in document.createElement('div') ?
+      'wheel' : // Modern browsers support "wheel"
+
+      document.onmousewheel !== undefined ?
+        'mousewheel' : // Webkit and IE support at least "mousewheel"
+        'DOMMouseScroll'; // let's assume that remaining browsers are older Firefox
+  };
+
+
+  /*
+    ---------------
+    Init
+
+    don't start script unless browser cuts the mustard
+    (also passes if polyfills are used)
+    ---------------
+  */
+
+  if (
+    'addEventListener' in window &&
+    Array.prototype.indexOf
+  ) {
+    setUp();
+  }
+
+
+  /*
+    ---------------
+    API
+    ---------------
+  */
+
+  return {
+
+    // returns string: the current input type
+    // opt: 'loose'|'strict'
+    // 'strict' (default): returns the same value as the `data-whatinput` attribute
+    // 'loose': includes `data-whatintent` value if it's more current than `data-whatinput`
+    ask: function(opt) { return (opt === 'loose') ? currentIntent : currentInput; },
+
+    // returns array: all the detected input types
+    types: function() { return inputTypes; }
+
+  };
+
+}());