ustyle 1.3.6

data/vendor/assets/javascripts/ustyle/login/login.js

@@ -0,0 +1,165 @@
+var ref             = this.Utils;
+var addClass        = ref.addClass;
+var merge           = ref.merge;
+var setOptions      = ref.setOptions;
+var deleteUndefined = ref.deleteUndefined;
+
+window.Login = (function(options) {
+  var Login;
+  return Login = (function() {
+    var passwordHelp;
+
+    Login.prototype.defaults = {
+      origin: window.location.href,
+      removeableClass: "us-login--removeable",
+      state: "signin"
+    };
+
+    function Login(options) {
+      var container;
+      this.options = setOptions(options, this.defaults);
+      if (this.options.target === null) {
+        return;
+      }
+
+      if (!(this.options.target.length === void 0 || this.options.target.length)) {
+        return;
+      }
+
+      this.target = $(this.options.target);
+      this.formData = {
+        source: this.target.data("source"),
+        origin: this.target.data("origin") || this.options.origin,
+        email: this.target.data("email"),
+        "opt_in": this.target.data("opt-in")
+      };
+
+      deleteUndefined(this.formData);
+      this.title = this.target.data("title") || this.options.title;
+      this.description = this.target.data("description");
+      container = document.createElement("div");
+      addClass(container, "us-anchor__target");
+      addClass(container, "us-login__target");
+      this.setupAnchors(container);
+    }
+
+    Login.prototype.setupAnchors = function(container) {
+      var i;
+      var len;
+      var ref1;
+      var results;
+      var target;
+      if (this.options.target.length >= 1) {
+        ref1 = this.options.target;
+        results = [];
+
+        for (i = 0, len = ref1.length; i < len; i++) {
+          target = ref1[i];
+          results.push(this.anchorInstance(target, container));
+        }
+
+        return results;
+      } else {
+        return this.anchorInstance(this.options.target, container);
+      }
+    };
+
+    Login.prototype.anchorInstance = function(target, container) {
+      return this.anchor = new Anchor({
+        target: target,
+        content: container,
+        isAjax: true,
+        onOpen: (function(_this) {
+          return function() {
+            return _this.fetch().done(function(html) {
+              var ref1;
+
+              if (!$(container).find(".us-login__form").length) {
+                $(container).append(html);
+              }
+
+              _this.loginForm = $(container).find(".us-login__form");
+              _this.loginContainer = $(container).find(".us-login");
+              _this.setState();
+              _this.setContent();
+              passwordHelp(_this.loginForm);
+              return (ref1 = _this.options.onOpen) != null ? ref1.call(target) : void 0;
+            });
+          };
+        })(this),
+
+        onClose: (function(_this) {
+          return function() {
+            var ref1;
+            if ((ref1 = _this.options.onClose) != null) {
+              ref1.call(target);
+            }
+
+            return _this.resetForm();
+          };
+        })(this)
+      });
+    };
+
+    Login.prototype.fetch = function() {
+      var jqxhr;
+      return jqxhr = $.ajax({
+        url: (window.uSwitch.Accounts.popupUrl()) + "?" + ($.param(this.formData)),
+        dataType: "jsonp"
+      });
+    };
+
+    Login.prototype.setState = function() {
+      var activeState = this.loginForm.filter(".us-login__form--" + this.options.state);
+      this.loginForm.removeClass("login-state--active");
+      activeState.addClass("login-state--active");
+      return this.toggle();
+    };
+
+    Login.prototype.toggle = function() {
+      return $(document).on("click", ".login-state__toggle", function(e) {
+        var $currentState = $(this).parents(".us-login__form");
+        var $nextState = $currentState.next().length ? $currentState.next() : $currentState.prev();
+        $nextState.addClass("login-state--active");
+        $currentState.removeClass("login-state--active");
+        return e.preventDefault();
+      });
+    };
+
+    Login.prototype.setContent = function() {
+      var descriptionElm;
+      var loginTitle;
+      var selector;
+
+      if (!this.title) {
+        return;
+      }
+
+      selector = "<h2 class='us-login__title ";
+      selector += this.options.removeableClass + "'>" + this.title + "</h2>";
+      loginTitle = $(selector);
+      this.loginContainer.prepend(loginTitle);
+
+      if (!this.description) {
+        return;
+      }
+
+      descriptionElm = "<p class='us-login__description ";
+      descriptionElm += this.options.removeableClass + "'>" + this.description + "</p>";
+      return loginTitle.after(descriptionElm);
+    };
+
+    Login.prototype.resetForm = function() {
+      return $("." + this.options.removeableClass).remove();
+    };
+
+    passwordHelp = function(form) {
+      return window.setTimeout(function() {
+        return form.find(".password-strength").passwordHelper();
+      }, 1);
+    };
+
+    return Login;
+
+  })();
+})();

data/vendor/assets/javascripts/ustyle/login/password-helper.js

@@ -0,0 +1,151 @@
+var slice = [].slice;
+
+(function($, window, document) {
+  var PasswordHelper;
+  return PasswordHelper = (function() {
+    var createHiddenPassword;
+    var createWrapper;
+    var regMediumExp = "^(?=.*\\d)(?=.*[a-z])(?!.*\\s).{8,}$|" + "^(?=.*[a-z])(?=.*[A-Z])(?!.*\\s).{8,}$";
+
+    PasswordHelper.prototype.defaults = {
+      classPrefix: "pass-helper",
+      veryWeakText: "very weak",
+      minLength: 6,
+      tests: {
+        weak: new RegExp("^[a-zA-Z0-9]{6,}$"),
+        medium: new RegExp(regMediumExp),
+        strong: new RegExp("^(?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?!.*\\s).{8,}$")
+      },
+      showHide: true,
+      showText: "Show",
+      hideText: "Hide"
+    };
+
+    function PasswordHelper(el, options) {
+      this.tests = (this.options = $.extend({}, this.defaults, options)).tests;
+      this.$el = $(el);
+
+      if (this.$el.hasClass(this.options.classPrefix + "__input")) {
+        return;
+      }
+
+      this.$el.addClass(this.options.classPrefix + "__input");
+      this.wrapper = createWrapper(this.$el, this.options.classPrefix);
+      this.hiddenPassword = createHiddenPassword(this.$el, this.options.classPrefix);
+      this.strengthChecker();
+
+      if (this.options.showHide) {
+        this.showHide();
+      }
+    }
+
+    PasswordHelper.prototype.strengthChecker = function() {
+      var html = "<div class='" + this.options.classPrefix + "__meter'>";
+      html += "<div class='" + this.options.classPrefix + "__meter-bar' /></div>";
+      this.$el.after($(html));
+      var strengthMeter = $("." + this.options.classPrefix + "__meter-bar");
+
+      var strengthTest = (function(_this) {
+        return function(value) {
+          var condition;
+          if (!value.length) {
+            return strengthMeter.removeClass();
+          }
+
+          condition = value.length < _this.options.minLength;
+
+          if (condition) {
+            return strengthMeter.removeClass().addClass("very-weak");
+          }
+
+          return $.each(_this.tests, function(name, test) {
+            if (value.match(test)) {
+              return strengthMeter.removeClass().addClass(name);
+            }
+          });
+        };
+      })(this);
+
+      return $(document).on("keyup", "." + this.options.classPrefix + "__input", (function(_this) {
+        return function(e) {
+          var passwordValue;
+          passwordValue = $(e.target).val();
+          $("." + _this.options.classPrefix + "__input").addClass("strength--started");
+
+          if (!passwordValue.length) {
+            $("." + _this.options.classPrefix + "__input").removeClass("strength--started");
+          }
+
+          return strengthTest(passwordValue);
+        };
+      })(this));
+    };
+
+    PasswordHelper.prototype.showHide = function() {
+      var exp = "<a class='" + this.options.classPrefix + "__show-hide' />";
+      this.$el.after($(exp).text(this.options.showText));
+      var showClass = this.options.classPrefix + "__input--pass-shown";
+      return $("." + this.options.classPrefix + "__show-hide").on("click", (function(_this) {
+        return function(e) {
+          e.preventDefault();
+
+          if (!_this.$el.hasClass(showClass)) {
+            _this.$el.addClass(showClass);
+            _this.$el.prop("disabled", true).hide();
+            _this.hiddenPassword.prop("disabled", false).val(_this.$el.val()).show().focus();
+            return $(e.target).text(_this.options.hideText);
+          } else {
+            _this.$el.removeClass(showClass);
+            _this.$el.prop("disabled", false).val(_this.hiddenPassword.val()).show().focus();
+            _this.hiddenPassword.prop("disabled", true).hide();
+            return $(e.target).text(_this.options.showText);
+          }
+        };
+      })(this));
+    };
+
+    createHiddenPassword = function(el, classPrefix) {
+      var expression = "<input style='display: none' class='" + (el.attr("class")) + " ";
+      expression += classPrefix + "__input-hidden' type='text' ";
+      expression += "name='" + (el.attr("name")) + "' ";
+      expression += "placeholder='" + (el.attr("placeholder") || "") + "' ";
+      expression += "size='" + (el.attr("size")) + "' value='' disabled='disabled' />";
+      var input = $(expression);
+      el.after(input);
+      return input;
+    };
+
+    createWrapper = function(el, classPrefix) {
+      var wrapperCss = {
+        position: "relative",
+        height: el.css("height"),
+        display: el.css("display")
+      };
+
+      return el.wrap($("<div />").addClass(classPrefix + "__wrapper").css(wrapperCss));
+    };
+
+    $.fn.extend({
+      passwordHelper: function() {
+        var options = arguments[0];
+        var args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+        return this.each(function() {
+          var helper;
+          var $this = $(this);
+          var data = $(this).data("passwordHelper");
+
+          if (!data) {
+            helper = (data = new PasswordHelper(this, options));
+            $this.data("passwordHelper", helper);
+          }
+
+          if (typeof options === "string") {
+            return data[options].apply(data, args);
+          }
+        });
+      }
+    });
+
+    return PasswordHelper;
+  })();
+})(window.jQuery, window, document);

data/vendor/assets/javascripts/ustyle/overlay.js

@@ -0,0 +1,125 @@
+window.Overlay = (function(Utils) {
+  var addClass = Utils.addClass;
+  var hasClass = Utils.hasClass;
+  var removeClass = Utils.removeClass;
+  var setOptions = Utils.setOptions;
+  var requestAnimationFrame = Utils.requestAnimationFrame;
+
+  var defaults = {
+    bodyActiveClass: "us-overlay--open",
+    activeClass: "us-overlay-parent--active",
+    visibleClass: "us-overlay-parent--visible",
+    overlay: $(".us-overlay-parent"),
+    openButton: ".js-open-overlay",
+    closeButton: ".js-close-overlay",
+    historyStatus: "#seedeal",
+    history: false,
+    preventDefault: true,
+    animationSpeed: 300
+  };
+
+  function Overlay(options) {
+    this.overlay = (this.options = setOptions(options, defaults)).overlay;
+    if ((this.overlay != null) && (typeof Backdrop !== "undefined" && Backdrop !== null)) {
+      this.backdrop = new Backdrop();
+      this.addEventListeners();
+    } else {
+      throw new Error("There's no overlay or you haven't included Backdrop");
+    }
+  }
+
+  Overlay.prototype.addEventListeners = function() {
+    $(this.options.openButton).on("click.open-overlay", (function(_this) {
+      return function(e) {
+        if (_this.options.preventDefault) {
+          e.preventDefault();
+        }
+
+        return _this.show(e);
+      };
+    })(this));
+
+    this.overlay.on("click.close-overlay", (function(_this) {
+      return function(e) {
+        var results = [];
+        var closeTargets = _this.overlay.find(_this.options.closeButton).toArray();
+        var targets = [_this.overlay[0]].concat(closeTargets);
+
+        for (var i = targets.length - 1; i >= 0; i--) {
+          var target = targets[i];
+          if (e.target === target) {
+            if (_this.options.preventDefault) {
+              e.preventDefault();
+            }
+
+            _this.hide(e);
+            break;
+          } else {
+            results.push(void 0);
+          }
+        };
+
+        return results;
+      };
+    })(this));
+
+    if (this.hasHistory()) {
+      return window.onpopstate = (function(_this) {
+        return function(e) {
+          if (_this.isOpen()) {
+            return _this.hide(e);
+          }
+        };
+      })(this);
+    }
+  };
+
+  Overlay.prototype.show = function(e) {
+    var onFrame;
+    var _this = this;
+    $(document.body).addClass(this.options.bodyActiveClass);
+    this.backdrop.retain();
+    addClass(this.overlay[0], this.options.visibleClass);
+    onFrame = function() {
+      addClass(_this.overlay[0], _this.options.activeClass);
+      return setTimeout(function() {
+        var base;
+        return typeof (base = _this.options).onOpen === "function" ? base.onOpen(e) : void 0;
+      }, _this.options.animationSpeed);
+    };
+
+    requestAnimationFrame.call(window, onFrame);
+    if (this.hasHistory()) {
+      return history.pushState("open", window.document.title, this.options.historyStatus);
+    }
+  };
+
+  Overlay.prototype.hide = function(e) {
+    var onFrame;
+    var _this = this;
+    $(document.body).removeClass(this.options.bodyActiveClass);
+    this.backdrop.release();
+    onFrame = function() {
+      removeClass(_this.overlay[0], _this.options.activeClass);
+      return setTimeout(function() {
+        var base;
+        removeClass(_this.overlay[0], _this.options.visibleClass);
+        return typeof (base = _this.options).onClose === "function" ? base.onClose(e) : void 0;
+      }, _this.options.animationSpeed);
+    };
+
+    requestAnimationFrame.call(window, onFrame);
+    if (this.hasHistory() && history.state === "open") return history.back();
+  };
+
+  Overlay.prototype.isOpen = function() {
+    return hasClass(this.overlay[0], this.options.activeClass);
+  };
+
+  Overlay.prototype.hasHistory = function() {
+    return this.options.history && window.history && window.history.pushState;
+  };
+
+  return Overlay;
+
+})(this.Utils);

data/vendor/assets/javascripts/ustyle/radioToggle.js

@@ -0,0 +1,28 @@
+window.RadioToggle = (function() {
+  var defaults = {
+    $target: $(".us-toggle")
+  };
+
+  function RadioToggle(options) {
+    this.options = Utils.setOptions(options, defaults);
+    if (this.options.$target) {
+      this.addEventListeners();
+    } else {
+      throw new Error("No target defined");
+    }
+  }
+
+  RadioToggle.prototype.addEventListeners = function() {
+    return this.options.$target.on("change", "input:radio", function(e) {
+      $("input[name='" + this.name + "']").removeClass("checked");
+      if (this.checked) {
+        $(this).addClass("checked");
+      }
+
+      return e.stopPropagation();
+    });
+  };
+
+  return RadioToggle;
+
+})();

data/vendor/assets/javascripts/ustyle/tabs.js

@@ -0,0 +1,120 @@
+var setOptions = this.Utils.setOptions;
+
+window.Tabs = (function(options) {
+  var Tabs;
+  return Tabs = (function() {
+    var getSelector;
+
+    Tabs.prototype.defaults = {
+      tabContainer: ".us-tabs",
+      tabLinks: ".us-tabs-nav-mainlink",
+      tabNav: ".us-tabs-nav",
+      changeUrls: true,
+      activeClass: "active",
+      collapsible: false,
+      autoScroll: true
+    };
+
+    function Tabs(options) {
+      var ref = this.options = setOptions(options, this.defaults);
+      var tabContainer = ref.tabContainer;
+      var tabLinks = ref.tabLinks;
+
+      this.tabs = $(tabContainer).find(tabLinks);
+      this.filter = this.tabs.data("target") ? "data-target" : "href";
+      this.init();
+      this.tabs.on("click.ustyle.tab", (function(_this) {
+        return function(e) {
+          var $target = $(e.currentTarget);
+          if (_this.isAccordion() && _this.options.collapsible && _this.isActive($target)) {
+            _this.collapse($target);
+            _this.hashClear();
+          } else {
+            _this.navigateTo($target);
+            _this.scrollToTab($target);
+            _this.hashChange($target);
+          }
+
+          return e.preventDefault();
+        };
+      })(this));
+    }
+
+    Tabs.prototype.init = function() {
+      var $activeTab = this.activeTab();
+      var $initialHash = this.tabFromHash();
+
+      if ($initialHash.length) {
+        return this.navigateTo($initialHash);
+      } else if ($activeTab.length) {
+        return this.navigateTo($activeTab);
+      } else if (!this.options.collapsible || !this.isAccordion()) {
+        return this.navigateTo(this.tabs.first());
+      }
+    };
+
+    Tabs.prototype.hashChange = function(target) {
+      if (!this.options.changeUrls) {
+        return;
+      }
+
+      return location.replace("#!" + (getSelector(target).replace(/#/, "")));
+    };
+
+    Tabs.prototype.hashClear = function() {
+      if (!this.options.changeUrls) {
+        return;
+      }
+
+      var url = window.location.pathname + window.location.search;
+      return typeof history.replaceState === "function" ? history.replaceState("", document.title, url) : void 0;
+    };
+
+    Tabs.prototype.navigateTo = function(target) {
+      var selector = getSelector(target);
+      var $selected = $(selector);
+      this.tabs.removeClass(this.options.activeClass).end();
+      this.tabs.filter("[" + this.filter + "='" + selector + "']").addClass(this.options.activeClass);
+      $selected.siblings("." + this.options.activeClass).removeClass(this.options.activeClass).end().addClass(this.options.activeClass);
+      return $selected.trigger("ustyle.tab.active");
+    };
+
+    Tabs.prototype.collapse = function(target) {
+      var $selected = $(getSelector(target));
+      this.tabs.removeClass(this.options.activeClass).end();
+      return $selected.removeClass(this.options.activeClass);
+    };
+
+    Tabs.prototype.scrollToTab = function(target) {
+      if (!(this.isAccordion() && this.options.autoScroll)) {
+        return;
+      }
+
+      var $selected = $(getSelector(target));
+      return $("html,body").scrollTop($selected.offset().top);
+    };
+
+    Tabs.prototype.activeTab = function() {
+      return this.tabs.filter("." + this.options.activeClass);
+    };
+
+    Tabs.prototype.tabFromHash = function() {
+      var tabId = location.hash.replace("!", "");
+      return this.tabs.filter("[" + this.filter + "='" + tabId + "']");
+    };
+
+    Tabs.prototype.isActive = function(target) {
+      return getSelector(target) === getSelector(this.activeTab());
+    };
+
+    Tabs.prototype.isAccordion = function() {
+      return !$(this.options.tabNav).is(":visible");
+    };
+
+    getSelector = function(clicked) {
+      return clicked.data("target") || clicked.attr("href");
+    };
+
+    return Tabs;
+  })();
+})();

data/vendor/assets/javascripts/ustyle/utils.js

@@ -0,0 +1,106 @@
+var slice = [].slice;
+var hasProp = {}.hasOwnProperty;
+
+if (this.Utils == null) {
+  this.Utils = {
+    modules: []
+  };
+}
+
+var addClass = function(element, name) {
+  removeClass(element, name);
+  return element.className += " " + name + " ";
+};
+
+var removeClass = function(element, name) {
+  var regExp = new RegExp("(\\s|^)" + name + "(\\s|$)", "gi");
+  return element.className = element.className.replace(regExp, "");
+};
+
+var hasClass = function(element, name) {
+  return new RegExp("(^| )" + name + "( |$)", "gi").test(element.className);
+};
+
+var merge = function() {
+  var extension;
+  var i;
+  var len;
+  var property;
+  var target = arguments[0];
+  var extensions = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+
+  for (i = 0, len = extensions.length; i < len; i++) {
+    extension = extensions[i];
+    for (property in extension) {
+      if (!hasProp.call(extension, property)) continue;
+      target[property] = extension[property];
+    }
+  }
+
+  return target;
+};
+
+var setOptions = function(options, defaults) {
+  return merge({}, defaults, options);
+};
+
+var deleteUndefined = function(obj) {
+  var key;
+  var value;
+  var results = [];
+  for (key in obj) {
+    value = obj[key];
+    if (value === null || value === void 0) {
+      results.push(delete obj[key]);
+    } else {
+      results.push(void 0);
+    }
+  }
+
+  return results;
+};
+
+var transformKey = (function() {
+  var i;
+  var key;
+  var len;
+  var el = document.createElement("div");
+  var transforms = ["transform", "webkitTransform", "OTransform", "MozTransform", "msTransform"];
+  for (i = 0, len = transforms.length; i < len; i++) {
+    key = transforms[i];
+    if (el.style[key] !== void 0) {
+      return key;
+    }
+  }
+})();
+
+var requestAnimationFrame = (function(window) {
+  var i;
+  var len;
+  var vendor;
+  var ref =  ["ms", "moz", "webkit", "o"];
+
+  for (i = 0, len = ref.length; i < len; i++) {
+    vendor = ref[i];
+    if (window.requestAnimationFrame) {
+      break;
+    }
+
+    window.requestAnimationFrame = window[vendor + "RequestAnimationFrame"];
+  }
+
+  return window.requestAnimationFrame || (window.requestAnimationFrame = function(callback) {
+    return setTimeout(callback, 1000 / 60);
+  });
+})(window);
+
+this.Utils = {
+  addClass: addClass,
+  removeClass: removeClass,
+  hasClass: hasClass,
+  merge: merge,
+  setOptions: setOptions,
+  deleteUndefined: deleteUndefined,
+  transformKey: transformKey,
+  requestAnimationFrame: requestAnimationFrame
+};

data/vendor/assets/javascripts/ustyle.js

@@ -0,0 +1,7 @@
+//= require ustyle/anchor
+//= require ustyle/backdrop
+//= require ustyle/overlay
+//= require ustyle/tabs
+//= require ustyle/utils
+//= require ustyle/login/password-helper
+//= require ustyle/login/login