fluentd-ui 0.3.8 → 0.3.9

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

@@ -0,0 +1,151 @@
+var _ = require('../util')
+var applyCSSTransition = require('./css')
+var applyJSTransition = require('./js')
+
+/**
+ * Append with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.append = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * InsertBefore with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.before = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    _.before(el, target)
+  }, vm, cb)
+}
+
+/**
+ * Remove with transition.
+ *
+ * @oaram {Element} el
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.remove = function (el, vm, cb) {
+  apply(el, -1, function () {
+    _.remove(el)
+  }, vm, cb)
+}
+
+/**
+ * Remove by appending to another parent with transition.
+ * This is only used in block operations.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.removeThenAppend = function (el, target, vm, cb) {
+  apply(el, -1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * Append the childNodes of a fragment to target.
+ *
+ * @param {DocumentFragment} block
+ * @param {Node} target
+ * @param {Vue} vm
+ */
+
+exports.blockAppend = function (block, target, vm) {
+  var nodes = _.toArray(block.childNodes)
+  for (var i = 0, l = nodes.length; i < l; i++) {
+    exports.before(nodes[i], target, vm)
+  }
+}
+
+/**
+ * Remove a block of nodes between two edge nodes.
+ *
+ * @param {Node} start
+ * @param {Node} end
+ * @param {Vue} vm
+ */
+
+exports.blockRemove = function (start, end, vm) {
+  var node = start.nextSibling
+  var next
+  while (node !== end) {
+    next = node.nextSibling
+    exports.remove(node, vm)
+    node = next
+  }
+}
+
+/**
+ * Apply transitions with an operation callback.
+ *
+ * @oaram {Element} el
+ * @param {Number} direction
+ *                  1: enter
+ *                 -1: leave
+ * @param {Function} op - the actual DOM operation
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+var apply = exports.apply = function (el, direction, op, vm, cb) {
+  var transData = el.__v_trans
+  if (
+    !transData ||
+    !vm._isCompiled ||
+    // if the vm is being manipulated by a parent directive
+    // during the parent's compilation phase, skip the
+    // animation.
+    (vm.$parent && !vm.$parent._isCompiled)
+  ) {
+    op()
+    if (cb) cb()
+    return
+  }
+  // determine the transition type on the element
+  var jsTransition = vm.$options.transitions[transData.id]
+  if (jsTransition) {
+    // js
+    applyJSTransition(
+      el,
+      direction,
+      op,
+      transData,
+      jsTransition,
+      vm,
+      cb
+    )
+  } else if (_.transitionEndEvent) {
+    // css
+    applyCSSTransition(
+      el,
+      direction,
+      op,
+      transData,
+      cb
+    )
+  } else {
+    // not applicable
+    op()
+    if (cb) cb()
+  }
+}

data/vendor/assets/javascripts/bower/vue/src/transition/js.js

@@ -0,0 +1,43 @@
+/**
+ * Apply JavaScript enter/leave functions.
+ *
+ * @param {Element} el
+ * @param {Number} direction - 1: enter, -1: leave
+ * @param {Function} op - the actual DOM operation
+ * @param {Object} data - target element's transition data
+ * @param {Object} def - transition definition object
+ * @param {Vue} vm - the owner vm of the element
+ * @param {Function} [cb]
+ */
+
+module.exports = function (el, direction, op, data, def, vm, cb) {
+  if (data.cancel) {
+    data.cancel()
+    data.cancel = null
+  }
+  if (direction > 0) { // enter
+    if (def.beforeEnter) {
+      def.beforeEnter.call(vm, el)
+    }
+    op()
+    if (def.enter) {
+      data.cancel = def.enter.call(vm, el, function () {
+        data.cancel = null
+        if (cb) cb()
+      })
+    } else if (cb) {
+      cb()
+    }
+  } else { // leave
+    if (def.leave) {
+      data.cancel = def.leave.call(vm, el, function () {
+        data.cancel = null
+        op()
+        if (cb) cb()
+      })
+    } else {
+      op()
+      if (cb) cb()
+    }
+  }
+}

data/vendor/assets/javascripts/bower/vue/src/util/debug.js

@@ -0,0 +1,50 @@
+var config = require('../config')
+
+/**
+ * Enable debug utilities. The enableDebug() function and
+ * all _.log() & _.warn() calls will be dropped in the
+ * minified production build.
+ */
+
+enableDebug()
+
+function enableDebug () {
+  var hasConsole = typeof console !== 'undefined'
+  
+  /**
+   * Log a message.
+   *
+   * @param {String} msg
+   */
+
+  exports.log = function (msg) {
+    if (hasConsole && config.debug) {
+      console.log('[Vue info]: ' + msg)
+    }
+  }
+
+  /**
+   * We've got a problem here.
+   *
+   * @param {String} msg
+   */
+
+  exports.warn = function (msg) {
+    if (hasConsole && !config.silent) {
+      console.warn('[Vue warn]: ' + msg)
+      if (config.debug && console.trace) {
+        console.trace()
+      }
+    }
+  }
+
+  /**
+   * Assert asset exists
+   */
+
+  exports.assertAsset = function (val, type, id) {
+    if (!val) {
+      exports.warn('Failed to resolve ' + type + ': ' + id)
+    }
+  }
+}

data/vendor/assets/javascripts/bower/vue/src/util/dom.js

@@ -0,0 +1,176 @@
+var config = require('../config')
+
+/**
+ * Check if a node is in the document.
+ *
+ * @param {Node} node
+ * @return {Boolean}
+ */
+
+var doc =
+  typeof document !== 'undefined' &&
+  document.documentElement
+
+exports.inDoc = function (node) {
+  return doc && doc.contains(node)
+}
+
+/**
+ * Extract an attribute from a node.
+ *
+ * @param {Node} node
+ * @param {String} attr
+ */
+
+exports.attr = function (node, attr) {
+  attr = config.prefix + attr
+  var val = node.getAttribute(attr)
+  if (val !== null) {
+    node.removeAttribute(attr)
+  }
+  return val
+}
+
+/**
+ * Insert el before target
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.before = function (el, target) {
+  target.parentNode.insertBefore(el, target)
+}
+
+/**
+ * Insert el after target
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.after = function (el, target) {
+  if (target.nextSibling) {
+    exports.before(el, target.nextSibling)
+  } else {
+    target.parentNode.appendChild(el)
+  }
+}
+
+/**
+ * Remove el from DOM
+ *
+ * @param {Element} el
+ */
+
+exports.remove = function (el) {
+  el.parentNode.removeChild(el)
+}
+
+/**
+ * Prepend el to target
+ *
+ * @param {Element} el
+ * @param {Element} target 
+ */
+
+exports.prepend = function (el, target) {
+  if (target.firstChild) {
+    exports.before(el, target.firstChild)
+  } else {
+    target.appendChild(el)
+  }
+}
+
+/**
+ * Replace target with el
+ *
+ * @param {Element} target
+ * @param {Element} el
+ */
+
+exports.replace = function (target, el) {
+  var parent = target.parentNode
+  if (parent) {
+    parent.replaceChild(el, target)
+  }
+}
+
+/**
+ * Copy attributes from one element to another.
+ *
+ * @param {Element} from
+ * @param {Element} to
+ */
+
+exports.copyAttributes = function (from, to) {
+  if (from.hasAttributes()) {
+    var attrs = from.attributes
+    for (var i = 0, l = attrs.length; i < l; i++) {
+      var attr = attrs[i]
+      to.setAttribute(attr.name, attr.value)
+    }
+  }
+}
+
+/**
+ * Add event listener shorthand.
+ *
+ * @param {Element} el
+ * @param {String} event
+ * @param {Function} cb
+ */
+
+exports.on = function (el, event, cb) {
+  el.addEventListener(event, cb)
+}
+
+/**
+ * Remove event listener shorthand.
+ *
+ * @param {Element} el
+ * @param {String} event
+ * @param {Function} cb
+ */
+
+exports.off = function (el, event, cb) {
+  el.removeEventListener(event, cb)
+}
+
+/**
+ * Add class with compatibility for IE & SVG
+ *
+ * @param {Element} el
+ * @param {Strong} cls
+ */
+
+exports.addClass = function (el, cls) {
+  if (el.classList) {
+    el.classList.add(cls)
+  } else {
+    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+    if (cur.indexOf(' ' + cls + ' ') < 0) {
+      el.setAttribute('class', (cur + cls).trim())
+    }
+  }
+}
+
+/**
+ * Remove class with compatibility for IE & SVG
+ *
+ * @param {Element} el
+ * @param {Strong} cls
+ */
+
+exports.removeClass = function (el, cls) {
+  if (el.classList) {
+    el.classList.remove(cls)
+  } else {
+    var cur = ' ' + (el.getAttribute('class') || '') + ' '
+    var tar = ' ' + cls + ' '
+    while (cur.indexOf(tar) >= 0) {
+      cur = cur.replace(tar, ' ')
+    }
+    el.setAttribute('class', cur.trim())
+  }
+}

data/vendor/assets/javascripts/bower/vue/src/util/env.js

@@ -0,0 +1,74 @@
+/**
+ * Can we use __proto__?
+ *
+ * @type {Boolean}
+ */
+
+exports.hasProto = '__proto__' in {}
+
+/**
+ * Indicates we have a window
+ *
+ * @type {Boolean}
+ */
+
+var toString = Object.prototype.toString
+var inBrowser = exports.inBrowser =
+  typeof window !== 'undefined' &&
+  toString.call(window) !== '[object Object]'
+
+/**
+ * Defer a task to the start of the next event loop
+ *
+ * @param {Function} cb
+ * @param {Object} ctx
+ */
+
+var defer = inBrowser
+  ? (window.requestAnimationFrame ||
+    window.webkitRequestAnimationFrame ||
+    setTimeout)
+  : setTimeout
+
+exports.nextTick = function (cb, ctx) {
+  if (ctx) {
+    defer(function () { cb.call(ctx) }, 0)
+  } else {
+    defer(cb, 0)
+  }
+}
+
+/**
+ * Detect if we are in IE9...
+ *
+ * @type {Boolean}
+ */
+
+exports.isIE9 =
+  inBrowser &&
+  navigator.userAgent.indexOf('MSIE 9.0') > 0
+
+/**
+ * Sniff transition/animation events
+ */
+
+if (inBrowser && !exports.isIE9) {
+  var isWebkitTrans =
+    window.ontransitionend === undefined &&
+    window.onwebkittransitionend !== undefined
+  var isWebkitAnim =
+    window.onanimationend === undefined &&
+    window.onwebkitanimationend !== undefined
+  exports.transitionProp = isWebkitTrans
+    ? 'WebkitTransition'
+    : 'transition'
+  exports.transitionEndEvent = isWebkitTrans
+    ? 'webkitTransitionEnd'
+    : 'transitionend'
+  exports.animationProp = isWebkitAnim
+    ? 'WebkitAnimation'
+    : 'animation'
+  exports.animationEndEvent = isWebkitAnim
+    ? 'webkitAnimationEnd'
+    : 'animationend'
+}