fluentd-ui 0.3.8 → 0.3.9

data/vendor/assets/javascripts/bower/vue/src/directives/index.js

@@ -1,129 +1,22 @@
-var utils      = require('../utils'),
-    config     = require('../config'),
-    transition = require('../transition'),
-    directives = module.exports = utils.hash()
-
-/**
- *  Nest and manage a Child VM
- */
-directives.component = {
-    isLiteral: true,
-    bind: function () {
-        if (!this.el.vue_vm) {
-            this.childVM = new this.Ctor({
-                el: this.el,
-                parent: this.vm
-            })
-        }
-    },
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-}
-
-/**
- *  Binding HTML attributes
- */
-directives.attr = {
-    bind: function () {
-        var params = this.vm.$options.paramAttributes
-        this.isParam = params && params.indexOf(this.arg) > -1
-    },
-    update: function (value) {
-        if (value || value === 0) {
-            this.el.setAttribute(this.arg, value)
-        } else {
-            this.el.removeAttribute(this.arg)
-        }
-        if (this.isParam) {
-            this.vm[this.arg] = utils.checkNumber(value)
-        }
-    }
-}
-
-/**
- *  Binding textContent
- */
-directives.text = {
-    bind: function () {
-        this.attr = this.el.nodeType === 3
-            ? 'nodeValue'
-            : 'textContent'
-    },
-    update: function (value) {
-        this.el[this.attr] = utils.guard(value)
-    }
-}
-
-/**
- *  Binding CSS display property
- */
-directives.show = function (value) {
-    var el = this.el,
-        target = value ? '' : 'none',
-        change = function () {
-            el.style.display = target
-        }
-    transition(el, value ? 1 : -1, change, this.compiler)
-}
-
-/**
- *  Binding CSS classes
- */
-directives['class'] = function (value) {
-    if (this.arg) {
-        utils[value ? 'addClass' : 'removeClass'](this.el, this.arg)
-    } else {
-        if (this.lastVal) {
-            utils.removeClass(this.el, this.lastVal)
-        }
-        if (value) {
-            utils.addClass(this.el, value)
-            this.lastVal = value
-        }
-    }
-}
-
-/**
- *  Only removed after the owner VM is ready
- */
-directives.cloak = {
-    isEmpty: true,
-    bind: function () {
-        var el = this.el
-        this.compiler.observer.once('hook:ready', function () {
-            el.removeAttribute(config.prefix + '-cloak')
-        })
-    }
-}
-
-/**
- *  Store a reference to self in parent VM's $
- */
-directives.ref = {
-    isLiteral: true,
-    bind: function () {
-        var id = this.expression
-        if (id) {
-            this.vm.$parent.$[id] = this.vm
-        }
-    },
-    unbind: function () {
-        var id = this.expression
-        if (id) {
-            delete this.vm.$parent.$[id]
-        }
-    }
-}
-
-directives.on      = require('./on')
-directives.repeat  = require('./repeat')
-directives.model   = require('./model')
-directives['if']   = require('./if')
-directives['with'] = require('./with')
-directives.html    = require('./html')
-directives.style   = require('./style')
-directives.partial = require('./partial')
-directives.view    = require('./view')
+// manipulation directives
+exports.text       = require('./text')
+exports.html       = require('./html')
+exports.attr       = require('./attr')
+exports.show       = require('./show')
+exports['class']   = require('./class')
+exports.el         = require('./el')
+exports.ref        = require('./ref')
+exports.cloak      = require('./cloak')
+exports.style      = require('./style')
+exports.partial    = require('./partial')
+exports.transition = require('./transition')
+
+// event listener directives
+exports.on         = require('./on')
+exports.model      = require('./model')
+
+// child vm directives
+exports.component  = require('./component')
+exports.repeat     = require('./repeat')
+exports['if']      = require('./if')
+exports['with']    = require('./with')

data/vendor/assets/javascripts/bower/vue/src/directives/model/checkbox.js

@@ -0,0 +1,25 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    this.listener = function () {
+      self.set(el.checked, true)
+    }
+    _.on(el, 'change', this.listener)
+    if (el.checked) {
+      this._initValue = el.checked
+    }
+  },
+
+  update: function (value) {
+    this.el.checked = !!value
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+  }
+
+}

data/vendor/assets/javascripts/bower/vue/src/directives/model/default.js

@@ -0,0 +1,123 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+
+    // check params
+    // - lazy: update model on "change" instead of "input"
+    var lazy = this._checkParam('lazy') != null
+    // - number: cast value into number when updating model.
+    var number = this._checkParam('number') != null
+
+    // handle composition events.
+    // http://blog.evanyou.me/2014/01/03/composition-event/
+    var cpLocked = false
+    this.cpLock = function () {
+      cpLocked = true
+    }
+    this.cpUnlock = function () {
+      cpLocked = false
+      // in IE11 the "compositionend" event fires AFTER
+      // the "input" event, so the input handler is blocked
+      // at the end... have to call it here.
+      set()
+    }
+    _.on(el,'compositionstart', this.cpLock)
+    _.on(el,'compositionend', this.cpUnlock)
+
+    // shared setter
+    function set () {
+      self.set(
+        number ? _.toNumber(el.value) : el.value,
+        true
+      )
+    }
+
+    // if the directive has filters, we need to
+    // record cursor position and restore it after updating
+    // the input with the filtered value.
+    // also force update for type="range" inputs to enable
+    // "lock in range" (see #506)
+    this.listener = this.filters || el.type === 'range'
+      ? function textInputListener () {
+          if (cpLocked) return
+          var charsOffset
+          // some HTML5 input types throw error here
+          try {
+            // record how many chars from the end of input
+            // the cursor was at
+            charsOffset = el.value.length - el.selectionStart
+          } catch (e) {}
+          // Fix IE10/11 infinite update cycle
+          // https://github.com/yyx990803/vue/issues/592
+          /* istanbul ignore if */
+          if (charsOffset < 0) {
+            return
+          }
+          set()
+          _.nextTick(function () {
+            // force a value update, because in
+            // certain cases the write filters output the
+            // same result for different input values, and
+            // the Observer set events won't be triggered.
+            var newVal = self._watcher.value
+            self.update(newVal)
+            if (charsOffset != null) {
+              var cursorPos =
+                _.toString(newVal).length - charsOffset
+              el.setSelectionRange(cursorPos, cursorPos)
+            }
+          })
+        }
+      : function textInputListener () {
+          if (cpLocked) return
+          set()
+        }
+
+    this.event = lazy ? 'change' : 'input'
+    _.on(el, this.event, this.listener)
+
+    // IE9 doesn't fire input event on backspace/del/cut
+    if (!lazy && _.isIE9) {
+      this.onCut = function () {
+        _.nextTick(self.listener)
+      }
+      this.onDel = function (e) {
+        if (e.keyCode === 46 || e.keyCode === 8) {
+          self.listener()
+        }
+      }
+      _.on(el, 'cut', this.onCut)
+      _.on(el, 'keyup', this.onDel)
+    }
+
+    // set initial value if present
+    if (
+      el.hasAttribute('value') ||
+      (el.tagName === 'TEXTAREA' && el.value.trim())
+    ) {
+      this._initValue = number
+        ? _.toNumber(el.value)
+        : el.value
+    }
+  },
+
+  update: function (value) {
+    this.el.value = _.toString(value)
+  },
+
+  unbind: function () {
+    var el = this.el
+    _.off(el, this.event, this.listener)
+    _.off(el,'compositionstart', this.cpLock)
+    _.off(el,'compositionend', this.cpUnlock)
+    if (this.onCut) {
+      _.off(el,'cut', this.onCut)
+      _.off(el,'keyup', this.onDel)
+    }
+  }
+
+}

data/vendor/assets/javascripts/bower/vue/src/directives/model/index.js

@@ -0,0 +1,56 @@
+var _ = require('../../util')
+
+var handlers = {
+  _default: require('./default'),
+  radio: require('./radio'),
+  select: require('./select'),
+  checkbox: require('./checkbox')
+}
+
+module.exports = {
+
+  priority: 800,
+  twoWay: true,
+  handlers: handlers,
+
+  /**
+   * Possible elements:
+   *   <select>
+   *   <textarea>
+   *   <input type="*">
+   *     - text
+   *     - checkbox
+   *     - radio
+   *     - number
+   *     - TODO: more types may be supplied as a plugin
+   */
+
+  bind: function () {
+    // friendly warning...
+    var filters = this.filters
+    if (filters && filters.read && !filters.write) {
+      _.warn(
+        'It seems you are using a read-only filter with ' +
+        'v-model. You might want to use a two-way filter ' +
+        'to ensure correct behavior.'
+      )
+    }
+    var el = this.el
+    var tag = el.tagName
+    var handler
+    if (tag === 'INPUT') {
+      handler = handlers[el.type] || handlers._default
+    } else if (tag === 'SELECT') {
+      handler = handlers.select
+    } else if (tag === 'TEXTAREA') {
+      handler = handlers._default
+    } else {
+      _.warn("v-model doesn't support element type: " + tag)
+      return
+    }
+    handler.bind.call(this)
+    this.update = handler.update
+    this.unbind = handler.unbind
+  }
+
+}

data/vendor/assets/javascripts/bower/vue/src/directives/model/radio.js

@@ -0,0 +1,26 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    this.listener = function () {
+      self.set(el.value, true)
+    }
+    _.on(el, 'change', this.listener)
+    if (el.checked) {
+      this._initValue = el.value
+    }
+  },
+
+  update: function (value) {
+    /* jshint eqeqeq: false */
+    this.el.checked = value == this.el.value
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+  }
+
+}

data/vendor/assets/javascripts/bower/vue/src/directives/model/select.js

@@ -0,0 +1,166 @@
+var _ = require('../../util')
+var Watcher = require('../../watcher')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    // check options param
+    var optionsParam = this._checkParam('options')
+    if (optionsParam) {
+      initOptions.call(this, optionsParam)
+    }
+    this.multiple = el.hasAttribute('multiple')
+    this.listener = function () {
+      var value = self.multiple
+        ? getMultiValue(el)
+        : el.value
+      self.set(value, true)
+    }
+    _.on(el, 'change', this.listener)
+    checkInitialValue.call(this)
+  },
+
+  update: function (value) {
+    /* jshint eqeqeq: false */
+    var el = this.el
+    el.selectedIndex = -1
+    var multi = this.multiple && _.isArray(value)
+    var options = el.options
+    var i = options.length
+    var option
+    while (i--) {
+      option = options[i]
+      option.selected = multi
+        ? indexOf(value, option.value) > -1
+        : value == option.value
+    }
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+    if (this.optionWatcher) {
+      this.optionWatcher.teardown()
+    }
+  }
+
+}
+
+/**
+ * Initialize the option list from the param.
+ *
+ * @param {String} expression
+ */
+
+function initOptions (expression) {
+  var self = this
+  function optionUpdateWatcher (value) {
+    if (_.isArray(value)) {
+      self.el.innerHTML = ''
+      buildOptions(self.el, value)
+      if (self._watcher) {
+        self.update(self._watcher.value)
+      }
+    } else {
+      _.warn('Invalid options value for v-model: ' + value)
+    }
+  }
+  this.optionWatcher = new Watcher(
+    this.vm,
+    expression,
+    optionUpdateWatcher
+  )
+  // update with initial value
+  optionUpdateWatcher(this.optionWatcher.value)
+}
+
+/**
+ * Build up option elements. IE9 doesn't create options
+ * when setting innerHTML on <select> elements, so we have
+ * to use DOM API here.
+ *
+ * @param {Element} parent - a <select> or an <optgroup>
+ * @param {Array} options
+ */
+
+function buildOptions (parent, options) {
+  var op, el
+  for (var i = 0, l = options.length; i < l; i++) {
+    op = options[i]
+    if (!op.options) {
+      el = document.createElement('option')
+      if (typeof op === 'string') {
+        el.text = el.value = op
+      } else {
+        el.text = op.text
+        el.value = op.value
+      }
+    } else {
+      el = document.createElement('optgroup')
+      el.label = op.label
+      buildOptions(el, op.options)
+    }
+    parent.appendChild(el)
+  }
+}
+
+/**
+ * Check the initial value for selected options.
+ */
+
+function checkInitialValue () {
+  var initValue
+  var options = this.el.options
+  for (var i = 0, l = options.length; i < l; i++) {
+    if (options[i].hasAttribute('selected')) {
+      if (this.multiple) {
+        (initValue || (initValue = []))
+          .push(options[i].value)
+      } else {
+        initValue = options[i].value
+      }
+    }
+  }
+  if (initValue) {
+    this._initValue = initValue
+  }
+}
+
+/**
+ * Helper to extract a value array for select[multiple]
+ *
+ * @param {SelectElement} el
+ * @return {Array}
+ */
+
+function getMultiValue (el) {
+  return Array.prototype.filter
+    .call(el.options, filterSelected)
+    .map(getOptionValue)
+}
+
+function filterSelected (op) {
+  return op.selected
+}
+
+function getOptionValue (op) {
+  return op.value || op.text
+}
+
+/**
+ * Native Array.indexOf uses strict equal, but in this
+ * case we need to match string/numbers with soft equal.
+ *
+ * @param {Array} arr
+ * @param {*} val
+ */
+
+function indexOf (arr, val) {
+  /* jshint eqeqeq: false */
+  var i = arr.length
+  while (i--) {
+    if (arr[i] == val) return i
+  }
+  return -1
+}