summaryrefslogtreecommitdiff
path: root/website/static/js/foundation/foundation.js
diff options
context:
space:
mode:
Diffstat (limited to 'website/static/js/foundation/foundation.js')
-rw-r--r--website/static/js/foundation/foundation.js464
1 files changed, 464 insertions, 0 deletions
diff --git a/website/static/js/foundation/foundation.js b/website/static/js/foundation/foundation.js
new file mode 100644
index 0000000..e9050c5
--- /dev/null
+++ b/website/static/js/foundation/foundation.js
@@ -0,0 +1,464 @@
+/*
+ * Foundation Responsive Library
+ * http://foundation.zurb.com
+ * Copyright 2013, ZURB
+ * Free to use under the MIT license.
+ * http://www.opensource.org/licenses/mit-license.php
+*/
+
+/*jslint unparam: true, browser: true, indent: 2 */
+
+// Accommodate running jQuery or Zepto in noConflict() mode by
+// using an anonymous function to redefine the $ shorthand name.
+// See http://docs.jquery.com/Using_jQuery_with_Other_Libraries
+// and http://zeptojs.com/
+var libFuncName = null;
+
+if (typeof jQuery === "undefined" &&
+ typeof Zepto === "undefined" &&
+ typeof $ === "function") {
+ libFuncName = $;
+} else if (typeof jQuery === "function") {
+ libFuncName = jQuery;
+} else if (typeof Zepto === "function") {
+ libFuncName = Zepto;
+} else {
+ throw new TypeError();
+}
+
+(function ($, window, document, undefined) {
+ 'use strict';
+
+ /*
+ matchMedia() polyfill - Test a CSS media
+ type/query in JS. Authors & copyright (c) 2012:
+ Scott Jehl, Paul Irish, Nicholas Zakas.
+ Dual MIT/BSD license
+
+ https://github.com/paulirish/matchMedia.js
+ */
+
+ $('head').append('<meta class="foundation-mq-small">');
+ $('head').append('<meta class="foundation-mq-medium">');
+ $('head').append('<meta class="foundation-mq-large">');
+
+ window.matchMedia = window.matchMedia || (function( doc, undefined ) {
+
+ "use strict";
+
+ var bool,
+ docElem = doc.documentElement,
+ refNode = docElem.firstElementChild || docElem.firstChild,
+ // fakeBody required for <FF4 when executed in <head>
+ fakeBody = doc.createElement( "body" ),
+ div = doc.createElement( "div" );
+
+ div.id = "mq-test-1";
+ div.style.cssText = "position:absolute;top:-100em";
+ fakeBody.style.background = "none";
+ fakeBody.appendChild(div);
+
+ return function(q){
+
+ div.innerHTML = "&shy;<style media=\"" + q + "\"> #mq-test-1 { width: 42px; }</style>";
+
+ docElem.insertBefore( fakeBody, refNode );
+ bool = div.offsetWidth === 42;
+ docElem.removeChild( fakeBody );
+
+ return {
+ matches: bool,
+ media: q
+ };
+
+ };
+
+ }( document ));
+
+ // add dusty browser stuff
+ if (!Array.prototype.filter) {
+ Array.prototype.filter = function(fun /*, thisp */) {
+ "use strict";
+
+ if (this == null) {
+ throw new TypeError();
+ }
+
+ var t = Object(this),
+ len = t.length >>> 0;
+ if (typeof fun !== "function") {
+ return;
+ }
+
+ var res = [],
+ thisp = arguments[1];
+ for (var i = 0; i < len; i++) {
+ if (i in t) {
+ var val = t[i]; // in case fun mutates this
+ if (fun && fun.call(thisp, val, i, t)) {
+ res.push(val);
+ }
+ }
+ }
+
+ return res;
+ }
+ }
+
+ if (!Function.prototype.bind) {
+ Function.prototype.bind = function (oThis) {
+ if (typeof this !== "function") {
+ // closest thing possible to the ECMAScript 5 internal IsCallable function
+ throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
+ }
+
+ var aArgs = Array.prototype.slice.call(arguments, 1),
+ fToBind = this,
+ fNOP = function () {},
+ fBound = function () {
+ return fToBind.apply(this instanceof fNOP && oThis
+ ? this
+ : oThis,
+ aArgs.concat(Array.prototype.slice.call(arguments)));
+ };
+
+ fNOP.prototype = this.prototype;
+ fBound.prototype = new fNOP();
+
+ return fBound;
+ };
+ }
+
+ if (!Array.prototype.indexOf) {
+ Array.prototype.indexOf = function (searchElement /*, fromIndex */ ) {
+ "use strict";
+ if (this == null) {
+ throw new TypeError();
+ }
+ var t = Object(this);
+ var len = t.length >>> 0;
+ if (len === 0) {
+ return -1;
+ }
+ var n = 0;
+ if (arguments.length > 1) {
+ n = Number(arguments[1]);
+ if (n != n) { // shortcut for verifying if it's NaN
+ n = 0;
+ } else if (n != 0 && n != Infinity && n != -Infinity) {
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
+ }
+ }
+ if (n >= len) {
+ return -1;
+ }
+ var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
+ for (; k < len; k++) {
+ if (k in t && t[k] === searchElement) {
+ return k;
+ }
+ }
+ return -1;
+ }
+ }
+
+ // fake stop() for zepto.
+ $.fn.stop = $.fn.stop || function() {
+ return this;
+ };
+
+ window.Foundation = {
+ name : 'Foundation',
+
+ version : '4.3.2',
+
+ cache : {},
+
+ media_queries : {
+ small : $('.foundation-mq-small').css('font-family').replace(/\'/g, ''),
+ medium : $('.foundation-mq-medium').css('font-family').replace(/\'/g, ''),
+ large : $('.foundation-mq-large').css('font-family').replace(/\'/g, '')
+ },
+
+ stylesheet : $('<style></style>').appendTo('head')[0].sheet,
+
+ init : function (scope, libraries, method, options, response, /* internal */ nc) {
+ var library_arr,
+ args = [scope, method, options, response],
+ responses = [],
+ nc = nc || false;
+
+ // disable library error catching,
+ // used for development only
+ if (nc) this.nc = nc;
+
+ // check RTL
+ this.rtl = /rtl/i.test($('html').attr('dir'));
+
+ // set foundation global scope
+ this.scope = scope || this.scope;
+
+ if (libraries && typeof libraries === 'string' && !/reflow/i.test(libraries)) {
+ if (/off/i.test(libraries)) return this.off();
+
+ library_arr = libraries.split(' ');
+
+ if (library_arr.length > 0) {
+ for (var i = library_arr.length - 1; i >= 0; i--) {
+ responses.push(this.init_lib(library_arr[i], args));
+ }
+ }
+ } else {
+ if (/reflow/i.test(libraries)) args[1] = 'reflow';
+
+ for (var lib in this.libs) {
+ responses.push(this.init_lib(lib, args));
+ }
+ }
+
+ // if first argument is callback, add to args
+ if (typeof libraries === 'function') {
+ args.unshift(libraries);
+ }
+
+ return this.response_obj(responses, args);
+ },
+
+ response_obj : function (response_arr, args) {
+ for (var i = 0, len = args.length; i < len; i++) {
+ if (typeof args[i] === 'function') {
+ return args[i]({
+ errors: response_arr.filter(function (s) {
+ if (typeof s === 'string') return s;
+ })
+ });
+ }
+ }
+
+ return response_arr;
+ },
+
+ init_lib : function (lib, args) {
+ return this.trap(function () {
+ if (this.libs.hasOwnProperty(lib)) {
+ this.patch(this.libs[lib]);
+ return this.libs[lib].init.apply(this.libs[lib], args);
+ } else {
+ return function () {};
+ }
+ }.bind(this), lib);
+ },
+
+ trap : function (fun, lib) {
+ if (!this.nc) {
+ try {
+ return fun();
+ } catch (e) {
+ return this.error({name: lib, message: 'could not be initialized', more: e.name + ' ' + e.message});
+ }
+ }
+
+ return fun();
+ },
+
+ patch : function (lib) {
+ this.fix_outer(lib);
+ lib.scope = this.scope;
+ lib.rtl = this.rtl;
+ },
+
+ inherit : function (scope, methods) {
+ var methods_arr = methods.split(' ');
+
+ for (var i = methods_arr.length - 1; i >= 0; i--) {
+ if (this.lib_methods.hasOwnProperty(methods_arr[i])) {
+ this.libs[scope.name][methods_arr[i]] = this.lib_methods[methods_arr[i]];
+ }
+ }
+ },
+
+ random_str : function (length) {
+ var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
+
+ if (!length) {
+ length = Math.floor(Math.random() * chars.length);
+ }
+
+ var str = '';
+ for (var i = 0; i < length; i++) {
+ str += chars[Math.floor(Math.random() * chars.length)];
+ }
+ return str;
+ },
+
+ libs : {},
+
+ // methods that can be inherited in libraries
+ lib_methods : {
+ set_data : function (node, data) {
+ // this.name references the name of the library calling this method
+ var id = [this.name,+new Date(),Foundation.random_str(5)].join('-');
+
+ Foundation.cache[id] = data;
+ node.attr('data-' + this.name + '-id', id);
+ return data;
+ },
+
+ get_data : function (node) {
+ return Foundation.cache[node.attr('data-' + this.name + '-id')];
+ },
+
+ remove_data : function (node) {
+ if (node) {
+ delete Foundation.cache[node.attr('data-' + this.name + '-id')];
+ node.attr('data-' + this.name + '-id', '');
+ } else {
+ $('[data-' + this.name + '-id]').each(function () {
+ delete Foundation.cache[$(this).attr('data-' + this.name + '-id')];
+ $(this).attr('data-' + this.name + '-id', '');
+ });
+ }
+ },
+
+ throttle : function(fun, delay) {
+ var timer = null;
+ return function () {
+ var context = this, args = arguments;
+ clearTimeout(timer);
+ timer = setTimeout(function () {
+ fun.apply(context, args);
+ }, delay);
+ };
+ },
+
+ // parses data-options attribute on nodes and turns
+ // them into an object
+ data_options : function (el) {
+ var opts = {}, ii, p,
+ opts_arr = (el.attr('data-options') || ':').split(';'),
+ opts_len = opts_arr.length;
+
+ function isNumber (o) {
+ return ! isNaN (o-0) && o !== null && o !== "" && o !== false && o !== true;
+ }
+
+ function trim(str) {
+ if (typeof str === 'string') return $.trim(str);
+ return str;
+ }
+
+ // parse options
+ for (ii = opts_len - 1; ii >= 0; ii--) {
+ p = opts_arr[ii].split(':');
+
+ if (/true/i.test(p[1])) p[1] = true;
+ if (/false/i.test(p[1])) p[1] = false;
+ if (isNumber(p[1])) p[1] = parseInt(p[1], 10);
+
+ if (p.length === 2 && p[0].length > 0) {
+ opts[trim(p[0])] = trim(p[1]);
+ }
+ }
+
+ return opts;
+ },
+
+ delay : function (fun, delay) {
+ return setTimeout(fun, delay);
+ },
+
+ // animated scrolling
+ scrollTo : function (el, to, duration) {
+ if (duration < 0) return;
+ var difference = to - $(window).scrollTop();
+ var perTick = difference / duration * 10;
+
+ this.scrollToTimerCache = setTimeout(function() {
+ if (!isNaN(parseInt(perTick, 10))) {
+ window.scrollTo(0, $(window).scrollTop() + perTick);
+ this.scrollTo(el, to, duration - 10);
+ }
+ }.bind(this), 10);
+ },
+
+ // not supported in core Zepto
+ scrollLeft : function (el) {
+ if (!el.length) return;
+ return ('scrollLeft' in el[0]) ? el[0].scrollLeft : el[0].pageXOffset;
+ },
+
+ // test for empty object or array
+ empty : function (obj) {
+ if (obj.length && obj.length > 0) return false;
+ if (obj.length && obj.length === 0) return true;
+
+ for (var key in obj) {
+ if (hasOwnProperty.call(obj, key)) return false;
+ }
+
+ return true;
+ },
+
+ addCustomRule : function(rule, media) {
+ if(media === undefined) {
+ Foundation.stylesheet.insertRule(rule, Foundation.stylesheet.cssRules.length);
+ } else {
+ var query = Foundation.media_queries[media];
+ if(query !== undefined) {
+ Foundation.stylesheet.insertRule('@media ' +
+ Foundation.media_queries[media] + '{ ' + rule + ' }');
+ }
+ }
+ }
+ },
+
+ fix_outer : function (lib) {
+ lib.outerHeight = function (el, bool) {
+ if (typeof Zepto === 'function') {
+ return el.height();
+ }
+
+ if (typeof bool !== 'undefined') {
+ return el.outerHeight(bool);
+ }
+
+ return el.outerHeight();
+ };
+
+ lib.outerWidth = function (el, bool) {
+ if (typeof Zepto === 'function') {
+ return el.width();
+ }
+
+ if (typeof bool !== 'undefined') {
+ return el.outerWidth(bool);
+ }
+
+ return el.outerWidth();
+ };
+ },
+
+ error : function (error) {
+ return error.name + ' ' + error.message + '; ' + error.more;
+ },
+
+ // remove all foundation events.
+ off: function () {
+ $(this.scope).off('.fndtn');
+ $(window).off('.fndtn');
+ return true;
+ },
+
+ zj : $
+ };
+
+ $.fn.foundation = function () {
+ var args = Array.prototype.slice.call(arguments, 0);
+
+ return this.each(function () {
+ Foundation.init.apply(Foundation, [this].concat(args));
+ return this;
+ });
+ };
+
+}(libFuncName, this, this.document));
generated by cgit (git 2.34.1) at 2024-12-21 07:47:07 +0000