migrations

private/js/lib/05_gsap.scrollToPlugin.js

@@ -0,0 +1,183 @@
+/*!
+ * VERSION: 1.9.0
+ * DATE: 2017-06-19
+ * UPDATES AND DOCS AT: http://greensock.com
+ *
+ * @license Copyright (c) 2008-2017, GreenSock. All rights reserved.
+ * This work is subject to the terms at http://greensock.com/standard-license or for
+ * Club GreenSock members, the software agreement that was issued with your membership.
+ *
+ * @author: Jack Doyle, jack@greensock.com
+ **/
+var _gsScope = (typeof(module) !== "undefined" && module.exports && typeof(global) !== "undefined") ? global : this || window; //helps ensure compatibility with AMD/RequireJS and CommonJS/Node
+(_gsScope._gsQueue || (_gsScope._gsQueue = [])).push( function() {
+
+	"use strict";
+
+	var _doc = (_gsScope.document || {}).documentElement,
+		_window = _gsScope,
+		_max = function(element, axis) {
+			var dim = (axis === "x") ? "Width" : "Height",
+				scroll = "scroll" + dim,
+				client = "client" + dim,
+				body = document.body;
+			return (element === _window || element === _doc || element === body) ? Math.max(_doc[scroll], body[scroll]) - (_window["inner" + dim] || _doc[client] || body[client]) : element[scroll] - element["offset" + dim];
+		},
+		_unwrapElement = function(value) {
+			if (typeof(value) === "string") {
+				value = TweenLite.selector(value);
+			}
+			if (value.length && value !== _window && value[0] && value[0].style && !value.nodeType) {
+				value = value[0];
+			}
+			return (value === _window || (value.nodeType && value.style)) ? value : null;
+		},
+		_buildGetter = function(e, axis) { //pass in an element and an axis ("x" or "y") and it'll return a getter function for the scroll position of that element (like scrollTop or scrollLeft, although if the element is the window, it'll use the pageXOffset/pageYOffset or the documentElement's scrollTop/scrollLeft or document.body's. Basically this streamlines things and makes a very fast getter across browsers.
+			var p = "scroll" + ((axis === "x") ? "Left" : "Top");
+			if (e === _window) {
+				if (e.pageXOffset != null) {
+					p = "page" + axis.toUpperCase() + "Offset";
+				} else if (_doc[p] != null) {
+					e = _doc;
+				} else {
+					e = document.body;
+				}
+			}
+			return function() {
+				return e[p];
+			};
+		},
+		_getOffset = function(element, container) {
+			var rect = _unwrapElement(element).getBoundingClientRect(),
+				isRoot = (!container || container === _window || container === document.body),
+				cRect = (isRoot ? _doc : container).getBoundingClientRect(),
+				offsets = {x: rect.left - cRect.left, y: rect.top - cRect.top};
+			if (!isRoot && container) { //only add the current scroll position if it's not the window/body.
+				offsets.x += _buildGetter(container, "x")();
+				offsets.y += _buildGetter(container, "y")();
+			}
+			return offsets;
+		},
+		_parseVal = function(value, target, axis) {
+			var type = typeof(value);
+			return !isNaN(value) ? parseFloat(value) : (type === "number" || (type === "string" && value.charAt(1) === "=")) ? value : (value === "max") ? _max(target, axis) : Math.min(_max(target, axis), _getOffset(value, target)[axis]);
+		},
+
+		ScrollToPlugin = _gsScope._gsDefine.plugin({
+			propName: "scrollTo",
+			API: 2,
+			global: true,
+			version:"1.9.0",
+
+			//called when the tween renders for the first time. This is where initial values should be recorded and any setup routines should run.
+			init: function(target, value, tween) {
+				this._wdw = (target === _window);
+				this._target = target;
+				this._tween = tween;
+				if (typeof(value) !== "object") {
+					value = {y:value}; //if we don't receive an object as the parameter, assume the user intends "y".
+					if (typeof(value.y) === "string" && value.y !== "max" && value.y.charAt(1) !== "=") {
+						value.x = value.y;
+					}
+				} else if (value.nodeType) {
+					value = {y:value, x:value};
+				}
+				this.vars = value;
+				this._autoKill = (value.autoKill !== false);
+				this.getX = _buildGetter(target, "x");
+				this.getY = _buildGetter(target, "y");
+				this.x = this.xPrev = this.getX();
+				this.y = this.yPrev = this.getY();
+				if (value.x != null) {
+					this._addTween(this, "x", this.x, _parseVal(value.x, target, "x") - (value.offsetX || 0), "scrollTo_x", true);
+					this._overwriteProps.push("scrollTo_x");
+				} else {
+					this.skipX = true;
+				}
+				if (value.y != null) {
+					this._addTween(this, "y", this.y, _parseVal(value.y, target, "y") - (value.offsetY || 0), "scrollTo_y", true);
+					this._overwriteProps.push("scrollTo_y");
+				} else {
+					this.skipY = true;
+				}
+				return true;
+			},
+
+			//called each time the values should be updated, and the ratio gets passed as the only parameter (typically it's a value between 0 and 1, but it can exceed those when using an ease like Elastic.easeOut or Back.easeOut, etc.)
+			set: function(v) {
+				this._super.setRatio.call(this, v);
+
+				var x = (this._wdw || !this.skipX) ? this.getX() : this.xPrev,
+					y = (this._wdw || !this.skipY) ? this.getY() : this.yPrev,
+					yDif = y - this.yPrev,
+					xDif = x - this.xPrev,
+					threshold = ScrollToPlugin.autoKillThreshold;
+
+				if (this.x < 0) { //can't scroll to a position less than 0! Might happen if someone uses a Back.easeOut or Elastic.easeOut when scrolling back to the top of the page (for example)
+					this.x = 0;
+				}
+				if (this.y < 0) {
+					this.y = 0;
+				}
+				if (this._autoKill) {
+					//note: iOS has a bug that throws off the scroll by several pixels, so we need to check if it's within 7 pixels of the previous one that we set instead of just looking for an exact match.
+					if (!this.skipX && (xDif > threshold || xDif < -threshold) && x < _max(this._target, "x")) {
+						this.skipX = true; //if the user scrolls separately, we should stop tweening!
+					}
+					if (!this.skipY && (yDif > threshold || yDif < -threshold) && y < _max(this._target, "y")) {
+						this.skipY = true; //if the user scrolls separately, we should stop tweening!
+					}
+					if (this.skipX && this.skipY) {
+						this._tween.kill();
+						if (this.vars.onAutoKill) {
+							this.vars.onAutoKill.apply(this.vars.onAutoKillScope || this._tween, this.vars.onAutoKillParams || []);
+						}
+					}
+				}
+				if (this._wdw) {
+					_window.scrollTo((!this.skipX) ? this.x : x, (!this.skipY) ? this.y : y);
+				} else {
+					if (!this.skipY) {
+						this._target.scrollTop = this.y;
+					}
+					if (!this.skipX) {
+						this._target.scrollLeft = this.x;
+					}
+				}
+				this.xPrev = this.x;
+				this.yPrev = this.y;
+			}
+
+		}),
+		p = ScrollToPlugin.prototype;
+
+	ScrollToPlugin.max = _max;
+	ScrollToPlugin.getOffset = _getOffset;
+	ScrollToPlugin.buildGetter = _buildGetter;
+	ScrollToPlugin.autoKillThreshold = 7;
+
+	p._kill = function(lookup) {
+		if (lookup.scrollTo_x) {
+			this.skipX = true;
+		}
+		if (lookup.scrollTo_y) {
+			this.skipY = true;
+		}
+		return this._super._kill.call(this, lookup);
+	};
+
+}); if (_gsScope._gsDefine) { _gsScope._gsQueue.pop()(); }
+
+//export to AMD/RequireJS and CommonJS/Node (precursor to full modular build system coming at a later date)
+(function(name) {
+	"use strict";
+	var getGlobal = function() {
+		return (_gsScope.GreenSockGlobals || _gsScope)[name];
+	};
+	if (typeof(module) !== "undefined" && module.exports) { //node
+		require("../TweenLite.js");
+		module.exports = getGlobal();
+	} else if (typeof(define) === "function" && define.amd) { //AMD
+		define(["TweenLite"], getGlobal);
+	}
+}("ScrollToPlugin"));

private/js/lib/06_countUp.js

@@ -0,0 +1,267 @@
+/*
+
+	countUp.js
+	by @inorganik
+
+*/
+
+// target = id of html element or var of previously selected html element where counting occurs
+// startVal = the value you want to begin at
+// endVal = the value you want to arrive at
+// decimals = number of decimal places, default 0
+// duration = duration of animation in seconds, default 2
+// options = optional object of options (see below)
+
+var CountUp = function(target, startVal, endVal, decimals, duration, options) {
+
+  var self = this;
+  self.version = function() {
+    return '1.9.3';
+  };
+
+  // default options
+  self.options = {
+    useEasing: true, // toggle easing
+    useGrouping: true, // 1,000,000 vs 1000000
+    separator: ',', // character to use as a separator
+    decimal: '.', // character to use as a decimal
+    easingFn: easeOutExpo, // optional custom easing function, default is Robert Penner's easeOutExpo
+    formattingFn: formatNumber, // optional custom formatting function, default is formatNumber above
+    prefix: '', // optional text before the result
+    suffix: '', // optional text after the result
+    numerals: [] // optionally pass an array of custom numerals for 0-9
+  };
+
+  // extend default options with passed options object
+  if (options && typeof options === 'object') {
+    for (var key in self.options) {
+      if (options.hasOwnProperty(key) && options[key] !== null) {
+        self.options[key] = options[key];
+      }
+    }
+  }
+
+  if (self.options.separator === '') {
+    self.options.useGrouping = false;
+  }
+  else {
+    // ensure the separator is a string (formatNumber assumes this)
+    self.options.separator = '' + self.options.separator;
+  }
+
+  // make sure requestAnimationFrame and cancelAnimationFrame are defined
+  // polyfill for browsers without native support
+  // by Opera engineer Erik Möller
+  var lastTime = 0;
+  var vendors = ['webkit', 'moz', 'ms', 'o'];
+  for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
+    window.requestAnimationFrame = window[vendors[x] + 'RequestAnimationFrame'];
+    window.cancelAnimationFrame = window[vendors[x] + 'CancelAnimationFrame'] || window[vendors[x] + 'CancelRequestAnimationFrame'];
+  }
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = function(callback, element) {
+      var currTime = new Date().getTime();
+      var timeToCall = Math.max(0, 16 - (currTime - lastTime));
+      var id = window.setTimeout(function() {
+        callback(currTime + timeToCall);
+      }, timeToCall);
+      lastTime = currTime + timeToCall;
+      return id;
+    };
+  }
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = function(id) {
+      clearTimeout(id);
+    };
+  }
+
+  function formatNumber(num) {
+    var neg = (num < 0),
+      x, x1, x2, x3, i, len;
+    num = Math.abs(num).toFixed(self.decimals);
+    num += '';
+    x = num.split('.');
+    x1 = x[0];
+    x2 = x.length > 1 ? self.options.decimal + x[1] : '';
+    if (self.options.useGrouping) {
+      x3 = '';
+      for (i = 0, len = x1.length; i < len; ++i) {
+        if (i !== 0 && ((i % 3) === 0)) {
+          x3 = self.options.separator + x3;
+        }
+        x3 = x1[len - i - 1] + x3;
+      }
+      x1 = x3;
+    }
+    // optional numeral substitution
+    if (self.options.numerals.length) {
+      x1 = x1.replace(/[0-9]/g, function(w) {
+        return self.options.numerals[+w];
+      })
+      x2 = x2.replace(/[0-9]/g, function(w) {
+        return self.options.numerals[+w];
+      })
+    }
+    return (neg ? '-' : '') + self.options.prefix + x1 + x2 + self.options.suffix;
+  }
+
+  // Robert Penner's easeOutExpo
+  function easeOutExpo(t, b, c, d) {
+    return c * (-Math.pow(2, -10 * t / d) + 1) * 1024 / 1023 + b;
+  }
+
+  function ensureNumber(n) {
+    return (typeof n === 'number' && !isNaN(n));
+  }
+
+  self.initialize = function() {
+    if (self.initialized) return true;
+
+    self.error = '';
+    self.d = (typeof target === 'string') ? document.getElementById(target) : target;
+    if (!self.d) {
+      self.error = '[CountUp] target is null or undefined'
+      return false;
+    }
+    self.startVal = Number(startVal);
+    self.endVal = Number(endVal);
+    // error checks
+    if (ensureNumber(self.startVal) && ensureNumber(self.endVal)) {
+      self.decimals = Math.max(0, decimals || 0);
+      self.dec = Math.pow(10, self.decimals);
+      self.duration = Number(duration) * 1000 || 2000;
+      self.countDown = (self.startVal > self.endVal);
+      self.frameVal = self.startVal;
+      self.initialized = true;
+      return true;
+    }
+    else {
+      self.error = '[CountUp] startVal (' + startVal + ') or endVal (' + endVal + ') is not a number';
+      return false;
+    }
+  };
+
+  // Print value to target
+  self.printValue = function(value) {
+    var result = self.options.formattingFn(value);
+
+    var hours = Math.floor(result / 60);
+    var minutes = Math.floor(result % 60);
+
+    if (hours < 10) {
+      hours = '0' + hours;
+    }
+
+    if (minutes < 10) {
+      minutes = '0' + minutes;
+    }
+
+    result = hours + ' <span>:</span> ' + minutes;
+
+    if (self.d.tagName === 'INPUT') {
+      this.d.value = result;
+    }
+    else if (self.d.tagName === 'text' || self.d.tagName === 'tspan') {
+      this.d.textContent = result;
+    }
+    else {
+      this.d.innerHTML = result;
+    }
+  };
+
+  self.count = function(timestamp) {
+
+    if (!self.startTime) {
+      self.startTime = timestamp;
+    }
+
+    self.timestamp = timestamp;
+    var progress = timestamp - self.startTime;
+    self.remaining = self.duration - progress;
+
+    // to ease or not to ease
+    if (self.options.useEasing) {
+      if (self.countDown) {
+        self.frameVal = self.startVal - self.options.easingFn(progress, 0, self.startVal - self.endVal, self.duration);
+      } else {
+        self.frameVal = self.options.easingFn(progress, self.startVal, self.endVal - self.startVal, self.duration);
+      }
+    } else {
+      if (self.countDown) {
+        self.frameVal = self.startVal - ((self.startVal - self.endVal) * (progress / self.duration));
+      } else {
+        self.frameVal = self.startVal + (self.endVal - self.startVal) * (progress / self.duration);
+      }
+    }
+
+    // don't go past endVal since progress can exceed duration in the last frame
+    if (self.countDown) {
+      self.frameVal = (self.frameVal < self.endVal) ? self.endVal : self.frameVal;
+    } else {
+      self.frameVal = (self.frameVal > self.endVal) ? self.endVal : self.frameVal;
+    }
+
+    // decimal
+    self.frameVal = Math.round(self.frameVal * self.dec) / self.dec;
+
+    // format and print value
+    self.printValue(self.frameVal);
+
+    // whether to continue
+    if (progress < self.duration) {
+      self.rAF = requestAnimationFrame(self.count);
+    } else {
+      if (self.callback) self.callback();
+    }
+  };
+  // start your animation
+  self.start = function(callback) {
+    if (!self.initialize()) return;
+    self.callback = callback;
+    self.rAF = requestAnimationFrame(self.count);
+  };
+  // toggles pause/resume animation
+  self.pauseResume = function() {
+    if (!self.paused) {
+      self.paused = true;
+      cancelAnimationFrame(self.rAF);
+    } else {
+      self.paused = false;
+      delete self.startTime;
+      self.duration = self.remaining;
+      self.startVal = self.frameVal;
+      requestAnimationFrame(self.count);
+    }
+  };
+  // reset to startVal so animation can be run again
+  self.reset = function() {
+    self.paused = false;
+    delete self.startTime;
+    self.initialized = false;
+    if (self.initialize()) {
+      cancelAnimationFrame(self.rAF);
+      self.printValue(self.startVal);
+    }
+  };
+  // pass a new endVal and start animation
+  self.update = function(newEndVal) {
+    if (!self.initialize()) return;
+    newEndVal = Number(newEndVal);
+    if (!ensureNumber(newEndVal)) {
+      self.error = '[CountUp] update() - new endVal is not a number: ' + newEndVal;
+      return;
+    }
+    self.error = '';
+    if (newEndVal === self.frameVal) return;
+    cancelAnimationFrame(self.rAF);
+    self.paused = false;
+    delete self.startTime;
+    self.startVal = self.frameVal;
+    self.endVal = newEndVal;
+    self.countDown = (self.startVal > self.endVal);
+    self.rAF = requestAnimationFrame(self.count);
+  };
+
+  // format startVal on initialization
+  if (self.initialize()) self.printValue(self.startVal);
+};