luda 0.1.5

data/assets/javascripts/luda/component.js

@@ -0,0 +1,240 @@
+//= require ./install
+//= require ./utilities
+//= require ./dom
+//= require ./event
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('./install.js'), require('./utilities.js'), require('./dom.js'), require('./event.js')) :
+  typeof define === 'function' && define.amd ? define(['./install.js', './utilities.js', './dom.js', './event.js'], factory) :
+  (factory());
+}(this, (function () { 'use strict';
+
+  var Component;
+
+  luda(Component = (function() {
+    class Component {
+      _hasDescendant(descendant) {
+        if (this._children.length && descendant) {
+          if (this._children.includes(descendant)) {
+            return true;
+          }
+          return this._children.some(function(child) {
+            return child._hasDescendant(descendant);
+          });
+        } else {
+          return false;
+        }
+      }
+
+      _observe() {
+        this._observer = new MutationObserver(this._onMutations.bind(this));
+        return this._observer.observe(this._$component, this.constructor._observerConfig);
+      }
+
+      _disconnect() {
+        this._observer.disconnect();
+        return this._observer = null;
+      }
+
+      static create($component) {
+        var $family, componentIsElementInstance, instance, parent;
+        componentIsElementInstance = $component instanceof Element;
+        if (!componentIsElementInstance) {
+          throw new Error(this._$COMPONENT_INVALID_ERROR);
+        }
+        $family = this._query$family($component);
+        instance = this.query($component);
+        if ($family._$parent) {
+          if (parent = this.query($family._$parent)) {
+            if (!instance) {
+              this._instances.push(instance = this._createInstance($component));
+            }
+            if (instance._parent !== parent) {
+              parent._children.push(instance) && (instance._parent = parent);
+            }
+            $family._$children.forEach(($child) => {
+              return this.create($child);
+            });
+            return instance;
+          } else {
+            this.create($family._$parent);
+            return this.query($component);
+          }
+        } else {
+          if (!instance) {
+            this._instances.push(instance = this._createInstance($component));
+          }
+          $family._$children.forEach(($child) => {
+            return this.create($child);
+          });
+          return instance;
+        }
+      }
+
+      static destroy(instance$component) {
+        var attribute, instance, results, value;
+        instance = this.query(instance$component);
+        if (instance) {
+          if (instance._observer) {
+            instance._disconnect();
+          }
+          if (instance._destroy) {
+            instance._destroy();
+          }
+          while (instance._children.length) {
+            this.destroy(instance._children[0]);
+          }
+          if (instance._parent) {
+            luda.except(instance, instance._parent._children);
+          }
+          luda.except(instance, this._instances);
+          results = [];
+          for (attribute in instance) {
+            value = instance[attribute];
+            results.push(instance[attribute] = null);
+          }
+          return results;
+        }
+      }
+
+      static query(instance$component) {
+        var instance;
+        instance = null;
+        if (instance$component instanceof this && this._instances.includes(instance$component)) {
+          instance = instance$component;
+        } else if (instance$component instanceof Element) {
+          this._instances.some(function(inited) {
+            if (inited._$component === instance$component) {
+              instance = inited;
+              return true;
+            }
+          });
+        }
+        return instance;
+      }
+
+      static _query$family($component) {
+        var _$children, _$parent;
+        _$parent = null;
+        _$children = [];
+        if (this._SELECTOR) {
+          _$parent = luda.$parent(this._SELECTOR, $component);
+          _$children = luda.$unnested(this._SELECTOR, $component, this._SELECTOR);
+        }
+        return {_$parent, _$children};
+      }
+
+      static _createInstance($component) {
+        var instance;
+        instance = new this();
+        instance._$component = $component;
+        instance._parent = null;
+        instance._children = [];
+        instance._observer = null;
+        if (instance._constructor) {
+          instance._constructor();
+        }
+        if (!(instance._observer && instance._onMutations && this._observerConfig)) {
+          instance._observe();
+        }
+        return instance;
+      }
+
+      static _observe(classObj) {
+        if (!Component._observer) {
+          Component._observer = new MutationObserver(function(mutations) {
+            return mutations.forEach(function(mutation) {
+              var $addedNodes, $removedNodes;
+              $removedNodes = Array.from(mutation.removedNodes);
+              $addedNodes = Array.from(mutation.addedNodes);
+              $removedNodes.forEach(function($node) {
+                if ($node instanceof Element) {
+                  return Component._Observed.forEach(function(Observed) {
+                    var $destroies;
+                    if ($node.matches(Observed._SELECTOR)) {
+                      return Observed.destroy($node);
+                    } else {
+                      $destroies = luda.$children(Observed._SELECTOR, $node);
+                      return $destroies.forEach(function($destroy) {
+                        return Observed.destroy($destroy);
+                      });
+                    }
+                  });
+                }
+              });
+              return $addedNodes.forEach(function($node) {
+                if ($node instanceof Element) {
+                  return Component._Observed.forEach(function(Observed) {
+                    var $creates;
+                    if ($node.matches(Observed._SELECTOR)) {
+                      return Observed.create($node);
+                    } else {
+                      $creates = luda.$children(Observed._SELECTOR, $node);
+                      return $creates.forEach(function($create) {
+                        return Observed.create($create);
+                      });
+                    }
+                  });
+                }
+              });
+            });
+          });
+          Component._observer.observe(document.documentElement, Component._observerConfig);
+        }
+        if (!Component._Observed.includes(classObj)) {
+          return Component._Observed.push(classObj);
+        }
+      }
+
+      static _install() {
+        var exposed, self;
+        self = this;
+        if (this === Component) {
+          return this;
+        }
+        if (!(this._SELECTOR || typeof this._SELECTOR !== 'string')) {
+          throw new Error(this._COMPONENT_NO_SELECTOR_ERROR);
+        }
+        if (!this.hasOwnProperty('_instances')) {
+          this._instances = [];
+        }
+        if (typeof this._init === 'function') {
+          exposed = this._init();
+        }
+        luda.on(luda._DOC_READY, function() {
+          luda.$children(self._SELECTOR).forEach(function($component) {
+            return self.create($component);
+          });
+          return Component._observe(self);
+        });
+        if (exposed) {
+          return exposed;
+        } else {
+          return this;
+        }
+      }
+
+    }
+    Component._SCOPE = 'Component';
+
+    Component._COMPONENT_NO_SELECTOR_ERROR = 'Extended component must has a css selector';
+
+    Component._$COMPONENT_INVALID_ERROR = '@param $component must be an instance of Element';
+
+    Component._SELECTOR = '';
+
+    Component._instances = [];
+
+    Component._Observed = [];
+
+    Component._observer = null;
+
+    Component._observerConfig = {
+      childList: true,
+      subtree: true
+    };
+
+    return Component;
+
+  }).call(this));
+
+})));

data/assets/javascripts/luda/constants.js

@@ -0,0 +1,18 @@
+//= require ./install
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('./install.js')) :
+  typeof define === 'function' && define.amd ? define(['./install.js'], factory) :
+  (factory());
+}(this, (function () { 'use strict';
+
+  luda({
+    KEY_LEFT: 37,
+    KEY_UP: 38,
+    KEY_RIGHT: 39,
+    KEY_DOWN: 40,
+    KEY_TAB: 9,
+    KEY_ESC: 27,
+    KEY_ENTER: 13
+  });
+
+})));

data/assets/javascripts/luda/degradation.js

@@ -0,0 +1,125 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory() :
+  typeof define === 'function' && define.amd ? define(factory) :
+  (factory());
+}(this, (function () { 'use strict';
+
+  var Degradation;
+
+  Degradation = {
+    _URL_ATTRIBUTE: 'data-degradation-url',
+    _HTML: ['<div id="luda-degradation-html" ', 'style="padding:100px 30px;text-align:center">', '<h1>Your Browser Is Too Old!</h1>', '<p>', 'Please visit this site with a modern browser ', '<a target="_blank" href="https://www.google.com/chrome/">', '(Chrome recommended)', '</a>', '.</p>', '</div>'].join(''),
+    _CSS_PROPERTIES: [
+      {
+        display: 'flex',
+        position: ['sticky',
+      'fixed']
+      },
+      'transition',
+      'animation'
+    ],
+    _JS_PROPERTIES: {
+      es6Class: 'class X {}',
+      es6ArrowFunction: '((x) => x)()'
+    },
+    _NOTIFY_MILLSECONDS: 500,
+    check: function() {
+      this._checkEnv();
+      this._checkJS(this._JS_PROPERTIES);
+      return this._checkCSS(this._CSS_PROPERTIES);
+    },
+    _eval: eval,
+    _checkEnv: function() {
+      if (typeof document !== 'undefined') {
+        if (typeof window !== 'undefined') {
+          return window;
+        }
+        if (typeof global !== 'undefined') {
+          return global;
+        }
+      }
+      throw new Error('Unsupported runtime environment.');
+    },
+    _checkJS: function(properties) {
+      var err, property, results, value;
+      results = [];
+      for (property in properties) {
+        value = properties[property];
+        try {
+          results.push(this._eval(value));
+        } catch (error) {
+          err = error;
+          this._notify();
+          throw new Error(property + ' ' + err);
+        }
+      }
+      return results;
+    },
+    _checkCSS: function(properties) {
+      var ele, i, len, name, property, results, value, valueEle;
+      ele = document.createElement('div');
+      results = [];
+      for (i = 0, len = properties.length; i < len; i++) {
+        property = properties[i];
+        if (typeof property === 'string') {
+          results.push(this._CSSPropertySupported(ele, property));
+        } else {
+          results.push((function() {
+            var results1;
+            results1 = [];
+            for (name in property) {
+              value = property[name];
+              this._CSSPropertySupported(ele, name);
+              if (value instanceof Array) {
+                results1.push((function() {
+                  var j, len1, results2;
+                  results2 = [];
+                  for (j = 0, len1 = value.length; j < len1; j++) {
+                    valueEle = value[j];
+                    results2.push(this._CSSValueSupported(ele, name, valueEle));
+                  }
+                  return results2;
+                }).call(this));
+              } else {
+                results1.push(this._CSSValueSupported(ele, name, value));
+              }
+            }
+            return results1;
+          }).call(this));
+        }
+      }
+      return results;
+    },
+    _CSSPropertySupported: function(ele, property) {
+      if (typeof ele.style[property] !== 'string') {
+        this._notify();
+        throw new Error('Unsupported CSS property: ' + property);
+      }
+    },
+    _CSSValueSupported: function(ele, property, value) {
+      ele.style[property] = value;
+      if (ele.style[property] !== value) {
+        this._notify();
+        throw new Error('Unsupported CSS property value: ' + property + ' ' + value);
+      }
+    },
+    _notify: function() {
+      var _self, redirectUrl;
+      redirectUrl = document.documentElement.getAttribute(this._URL_ATTRIBUTE);
+      if (redirectUrl) {
+        return location.href = redirectUrl;
+      }
+      _self = this;
+      return setInterval(function() {
+        if (!document.getElementById('luda-degradation-html')) {
+          if (document.body) {
+            return document.body.innerHTML = _self._HTML;
+          }
+        }
+      }, this._NOTIFY_MILLSECONDS);
+    }
+  };
+
+  Degradation.check();
+
+})));

data/assets/javascripts/luda/dom.js

@@ -0,0 +1,81 @@
+//= require ./install
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('./install.js')) :
+  typeof define === 'function' && define.amd ? define(['./install.js'], factory) :
+  (factory());
+}(this, (function () { 'use strict';
+
+  luda({
+    $child: function(selector, $ancestor) {
+      if (!$ancestor) {
+        $ancestor = document;
+      }
+      return $ancestor.querySelector(selector);
+    },
+    $children: function(selector, $ancestor) {
+      var $descendant, descendants;
+      if (!$ancestor) {
+        $ancestor = document;
+      }
+      $descendant = this.$child(selector, $ancestor);
+      if ($descendant) {
+        return descendants = Array.from($ancestor.querySelectorAll(selector));
+      } else {
+        return descendants = [];
+      }
+    },
+    $unnested: function(selector, $ancestor, ancestorSelector) {
+      var descendants;
+      descendants = this.$children(selector, $ancestor);
+      return descendants.filter(($descendant) => {
+        if (this.$parent(ancestorSelector, $descendant) === $ancestor) {
+          return $descendant;
+        }
+      });
+    },
+    $parent: function(selector, $descendant) {
+      var $ancestor;
+      $ancestor = $descendant.parentNode;
+      if ($ancestor) {
+        if ($ancestor.matches && $ancestor.matches(selector)) {
+          return $ancestor;
+        } else {
+          return this.$parent(selector, $ancestor);
+        }
+      }
+    },
+    $parents: function(selector, $descendant, _ancestors) {
+      var $ancestor;
+      $ancestor = this.$parent(selector, $descendant);
+      if (!_ancestors) {
+        _ancestors = [];
+      }
+      if ($ancestor) {
+        _ancestors.push($ancestor);
+        return this.$parents(selector, $ancestor, _ancestors);
+      } else {
+        return _ancestors;
+      }
+    },
+    $after: function($node, $target) {
+      var $parent;
+      $parent = $target.parentNode;
+      if ($parent.lastChild === $target) {
+        return $parent.appendChild($node);
+      } else {
+        return $parent.insertBefore($node, $target.nextSibling);
+      }
+    },
+    $prepend: function($node, $target) {
+      if ($target.firstChild) {
+        return $target.insertBefore($node, $target.firstChild);
+      } else {
+        return $target.appendChild($node);
+      }
+    },
+    reflow: function($element) {
+      return $element.offsetHeight;
+    }
+  });
+
+})));