interval-braining-ui-asset-pack 0.0.1 → 0.1.0

data/vendor/assets/bower_components/angular-ui-router-breadcrumbs/dist/angular-ui-router-breadcrumbs.js

@@ -0,0 +1,82 @@
+/**
+ * angular-ui-router state derived breadcrumbs
+ * @version v0.0.1-dev-2014-04-20
+ * @link https://github.com/interval-braining/angular-ui-router-breadcrumbs
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+
+(function (window, angular, undefined) {
+"use strict";
+// Source: src/ui_router_breadcrumbs.js
+/* exported breadcrumbs */
+var breadcrumbs = angular.module('ui.router.breadcrumbs', ['ng', 'ui.router']);
+
+// Source: src/directives/breadcrumbs.js
+breadcrumbs.directive('breadcrumbs', [
+  '$compile',
+  '$rootScope',
+  'breadcrumbs',
+  function($compile, $rootScope, breadcrumbs) {
+return {
+      link: {
+        pre: function link(scope, element, attrs) {
+          /* jshint unused: false */ /* for element, attrs */
+          scope.breadcrumbs = breadcrumbs;
+        }
+      },
+      restrict: 'AC'
+    };
+  }
+]);
+
+// Source: src/services/breadcrumbs.js
+breadcrumbs.provider('breadcrumbs', function BreadcrumbsProvider() {
+var compile;
+
+  function defaultCompiler(currentState) {
+    if(!currentState.breadcrumb) { return null; }
+
+    if(typeof currentState.breadcrumb === 'string') {
+      return {
+        text: currentState.breadcrumb,
+        stateName: currentState.name
+      };
+    } else {
+      return currentState.breadcrumb;
+    }
+  }
+
+  compile = defaultCompiler;
+
+  function refresh($state, breadcrumbs) {
+    var currentState = $state.$current,
+      breadcrumb;
+
+    breadcrumbs.length = 0;
+
+    while(currentState.parent) {
+      breadcrumb = compile(currentState.self);
+      if(breadcrumb) { breadcrumbs.unshift(breadcrumb); }
+      currentState = currentState.parent;
+    }
+    return breadcrumbs;
+  }
+
+  // Public Interface
+
+  this.compileWith = function(customCompiler) {
+    return compile = customCompiler || defaultCompiler;
+  };
+
+  this.$get = [
+    '$rootScope',
+    '$state',
+    function($rootScope, $state) {
+      var breadcrumbs = [];
+      refresh($state, breadcrumbs);
+      $rootScope.$on('$stateChangeSuccess', function() { refresh($state, breadcrumbs); });
+      return breadcrumbs;
+    }
+  ];
+});
+})(window, window.angular);

data/vendor/assets/bower_components/angular-ui-router-helpers/dist/angular-ui-router-helpers.js

@@ -0,0 +1,52 @@
+/**
+ * Helpful providers for angular-ui-router
+ * @version v0.0.1-dev-2014-04-20
+ * @link https://github.com/interval-braining/angular-ui-router-helpers
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+
+(function (window, angular, undefined) {
+"use strict";
+// Source: src/ui_router_helpers.js
+/* exported uiRouterHelpers */
+var uiRouterHelpers = angular.module('ui.router.helpers', ['ng', 'ui.router']);
+
+// Source: src/services/state_attr.js
+uiRouterHelpers.factory('stateAttr', [
+  '$rootScope',
+  '$state',
+  function($rootScope, $state) {
+var ProtoStateAttr = {
+      resetValue: function(event, toState, toParams, fromState, fromParams) {
+        /* jshint unused: false */ /* for full function signature */
+        this._value = null;
+      },
+      set: function(newValue) {
+        this._value = newValue;
+      },
+      value: function() {
+        return this._value || $state.current.data && $state.current.data[this.attrName];
+      }
+    };
+
+    function StateAttr(attrName) {
+      this.attrName = attrName;
+      this._value = null;
+    }
+
+    StateAttr.prototype = ProtoStateAttr;
+
+    return {
+      new: function(attrName, options) {
+        var attr = new StateAttr(attrName);
+        if(!options) { return attr; }
+
+        if(options.resetValueOnStateChange === true) {
+          $rootScope.$on('$stateChangeSuccess', function() { attr.resetValue(); });
+        }
+        return attr;
+      }
+    };
+  }
+]);
+})(window, window.angular);

data/vendor/assets/bower_components/angular-ui-router-hooks-before-state/dist/angular-ui-router-hooks-before-state.js

@@ -0,0 +1,56 @@
+/**
+ * angular-ui-router hook to execute logic before loading a state, possibly changing destination state
+ * @version v0.0.1-dev-2014-04-20
+ * @link https://github.com/interval-braining/angular-ui-router-hooks-before-state
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+
+(function (window, angular, undefined) {
+"use strict";
+// Source: src/ui_router_hooks_before_state.js
+var hookBeforeState = angular.module('ui.router.hooks.beforeState', ['ui.router']);
+
+function isInjectable(obj) {
+  return angular.isFunction(obj) ||
+    angular.isArray(obj) && angular.isString(obj[0]);
+}
+
+function processFilter($injector, $state, event, to, filter) {
+  var result = $injector.invoke(filter);
+
+  if (result) {
+    if(result.to) {
+      // Discontinue chain if redirection occurs
+      event.preventDefault();
+
+      $state.go(result.to, result.params, result.options);
+
+      return false;
+    } else if(result.params) {
+      angular.extend($state.params, result.params);
+    }
+  }
+  return result;
+}
+
+hookBeforeState.run([
+  '$rootScope',
+  '$state',
+  '$injector',
+  function($rootScope, $state, $injector) {
+    $rootScope.$on('$stateChangeStart', function(event, to) {
+      var filters, result;
+      if (!(filters = to.data.beforeState)) { return; }
+
+      if(isInjectable(filters)) {
+        processFilter($injector, $state, event, to, filters);
+      } else {
+        for(var i = 0; i < filters.length; i++) {
+          result = processFilter($injector, $state, event, to, filters[i]);
+          if(result === false) { return; }
+        }
+      }
+    });
+  }
+]);
+})(window, window.angular);

data/vendor/assets/bower_components/angular-validate-in-set/dist/angular-validate-in-set.js

@@ -0,0 +1,77 @@
+/**
+ * Angular directive providing set inclusion/exclusion validators for ngModel validation.
+ * @version v0.1.0
+ * @link https://github.com/interval-braining/angular-validate-in-set
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+
+(function (window, undefined) {
+"use strict";
+// Source: src/angular-validate-in-set.js
+(function() {
+var directiveValidateInSet = angular.module('directives.ngModel.validateInSet', []);
+
+  function inclusionDirective(directiveName, watchTrigger, watchFn) {
+    var directive, matches;
+
+    function extractMatches(matchList) {
+      if(!matchList) {
+        matches = [];
+        return;
+      }
+      if(!angular.isArray(matchList)) {
+        throw('Compilation failure, attribute value of in-set directive must compile to an Array');
+      }
+      matches = matchList;
+    }
+
+    function link(scope, elem, attrs, ctrl) {
+      function evaluateMatches(evalString) {
+        extractMatches(scope.$eval(evalString));
+      }
+      evaluateMatches(attrs[directiveName]);
+
+      attrs.$observe(directiveName, evaluateMatches);
+
+      scope.$watch(
+        function() {
+          return watchTrigger.call({matches: matches, ctrl: ctrl});
+        },
+        function(currentValue, previousValue) {
+          watchFn.call({
+            matches: matches,
+            ctrl: ctrl
+          }, currentValue, previousValue);
+        }
+      );
+    }
+
+    directive = {
+      link: link,
+      require: 'ngModel',
+      restrict: 'A',
+      scope: false
+    };
+
+    return function() { return directive; };
+  }
+
+  directiveValidateInSet.directive('inSet', [
+    inclusionDirective('inSet', function() {
+      return this.matches.length === 0 || this.matches.indexOf(this.ctrl.$modelValue) !== -1;
+    },
+    function(isIncluded) {
+      this.ctrl.$setValidity('inclusion', isIncluded);
+    })
+  ]);
+
+  directiveValidateInSet.directive('notInSet', [
+    inclusionDirective('notInSet', function() {
+      return this.matches.indexOf(this.ctrl.$modelValue) === -1;
+    },
+    function(isNotIncluded) {
+      this.ctrl.$setValidity('exclusion', isNotIncluded);
+    })
+  ]);
+})();
+})(window);