fluentd-ui 0.3.8 → 0.3.9

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

@@ -0,0 +1,32 @@
+// xlink
+var xlinkNS = 'http://www.w3.org/1999/xlink'
+var xlinkRE = /^xlink:/
+
+module.exports = {
+
+  priority: 850,
+
+  bind: function () {
+    var name = this.arg
+    this.update = xlinkRE.test(name)
+      ? xlinkHandler
+      : defaultHandler
+  }
+
+}
+
+function defaultHandler (value) {
+  if (value || value === 0) {
+    this.el.setAttribute(this.arg, value)
+  } else {
+    this.el.removeAttribute(this.arg)
+  }
+}
+
+function xlinkHandler (value) {
+  if (value != null) {
+    this.el.setAttributeNS(xlinkNS, this.arg, value)
+  } else {
+    this.el.removeAttributeNS(xlinkNS, 'href')
+  }
+}

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

@@ -0,0 +1,18 @@
+var _ = require('../util')
+var addClass = _.addClass
+var removeClass = _.removeClass
+
+module.exports = function (value) {
+  if (this.arg) {
+    var method = value ? addClass : removeClass
+    method(this.el, this.arg)
+  } else {
+    if (this.lastVal) {
+      removeClass(this.el, this.lastVal)
+    }
+    if (value) {
+      addClass(this.el, value)
+      this.lastVal = value
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+var config = require('../config')
+
+module.exports = {
+
+  bind: function () {
+    var el = this.el
+    this.vm.$once('hook:compiled', function () {
+      el.removeAttribute(config.prefix + 'cloak')
+    })
+  }
+
+}

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

@@ -0,0 +1,214 @@
+var _ = require('../util')
+var compile = require('../compiler/compile')
+var templateParser = require('../parsers/template')
+
+module.exports = {
+
+  isLiteral: true,
+
+  /**
+   * Setup. Two possible usages:
+   *
+   * - static:
+   *   v-component="comp"
+   *
+   * - dynamic:
+   *   v-component="{{currentView}}"
+   */
+
+  bind: function () {
+    if (!this.el.__vue__) {
+      // create a ref anchor
+      this.ref = document.createComment('v-component')
+      _.replace(this.el, this.ref)
+      // check keep-alive options.
+      // If yes, instead of destroying the active vm when
+      // hiding (v-if) or switching (dynamic literal) it,
+      // we simply remove it from the DOM and save it in a
+      // cache object, with its constructor id as the key.
+      this.keepAlive = this._checkParam('keep-alive') != null
+      if (this.keepAlive) {
+        this.cache = {}
+      }
+      // compile parent scope content
+      this.parentLinkFn = compile(
+        this.el, this.vm.$options,
+        true, // partial
+        true  // asParent
+      )
+      // if static, build right now.
+      if (!this._isDynamicLiteral) {
+        this.resolveCtor(this.expression)
+        this.childVM = this.build()
+        this.childVM.$before(this.ref)
+      } else {
+        // check dynamic component params
+        this.readyEvent = this._checkParam('wait-for')
+        this.transMode = this._checkParam('transition-mode')
+      }
+    } else {
+      _.warn(
+        'v-component="' + this.expression + '" cannot be ' +
+        'used on an already mounted instance.'
+      )
+    }
+  },
+
+  /**
+   * Resolve the component constructor to use when creating
+   * the child vm.
+   */
+
+  resolveCtor: function (id) {
+    this.ctorId = id
+    this.Ctor = this.vm.$options.components[id]
+    _.assertAsset(this.Ctor, 'component', id)
+  },
+
+  /**
+   * Instantiate/insert a new child vm.
+   * If keep alive and has cached instance, insert that
+   * instance; otherwise build a new one and cache it.
+   *
+   * @return {Vue} - the created instance
+   */
+
+  build: function () {
+    if (this.keepAlive) {
+      var cached = this.cache[this.ctorId]
+      if (cached) {
+        return cached
+      }
+    }
+    var vm = this.vm
+    var el = templateParser.clone(this.el)
+    if (this.Ctor) {
+      var parentUnlinkFn
+      if (this.parentLinkFn) {
+        parentUnlinkFn = this.parentLinkFn(vm, el)
+      }
+      var child = vm.$addChild({
+        el: el
+      }, this.Ctor)
+      child._parentUnlinkFn = parentUnlinkFn
+      if (this.keepAlive) {
+        this.cache[this.ctorId] = child
+      }
+      return child
+    }
+  },
+
+  /**
+   * Teardown the current child, but defers cleanup so
+   * that we can separate the destroy and removal steps.
+   */
+
+  unbuild: function () {
+    var child = this.childVM
+    if (!child || this.keepAlive) {
+      return
+    }
+    if (child._parentUnlinkFn) {
+      child._parentUnlinkFn()
+    }
+    // the sole purpose of `deferCleanup` is so that we can
+    // "deactivate" the vm right now and perform DOM removal
+    // later.
+    child.$destroy(false, true)
+  },
+
+  /**
+   * Remove current destroyed child and manually do
+   * the cleanup after removal.
+   *
+   * @param {Function} cb
+   */
+
+  removeCurrent: function (cb) {
+    var child = this.childVM
+    var keepAlive = this.keepAlive
+    if (child) {
+      child.$remove(function () {
+        if (!keepAlive) child._cleanup()
+        if (cb) cb()
+      })
+    } else if (cb) {
+      cb()
+    }
+  },
+
+  /**
+   * Update callback for the dynamic literal scenario,
+   * e.g. v-component="{{view}}"
+   */
+
+  update: function (value) {
+    if (!value) {
+      // just destroy and remove current
+      this.unbuild()
+      this.removeCurrent()
+      this.childVM = null
+    } else {
+      this.resolveCtor(value)
+      this.unbuild()
+      var newComponent = this.build()
+      var self = this
+      if (this.readyEvent) {
+        newComponent.$once(this.readyEvent, function () {
+          self.swapTo(newComponent)
+        })
+      } else {
+        this.swapTo(newComponent)
+      }
+    }
+  },
+
+  /**
+   * Actually swap the components, depending on the
+   * transition mode. Defaults to simultaneous.
+   *
+   * @param {Vue} target
+   */
+
+  swapTo: function (target) {
+    var self = this
+    switch (self.transMode) {
+      case 'in-out':
+        target.$before(self.ref, function () {
+          self.removeCurrent()
+          self.childVM = target
+        })
+        break
+      case 'out-in':
+        self.removeCurrent(function () {
+          target.$before(self.ref)
+          self.childVM = target
+        })
+        break
+      default:
+        self.removeCurrent()
+        target.$before(self.ref)
+        self.childVM = target
+    }
+  },
+
+  /**
+   * Unbind.
+   */
+
+  unbind: function () {
+    this.unbuild()
+    // destroy all keep-alive cached instances
+    if (this.cache) {
+      for (var key in this.cache) {
+        var child = this.cache[key]
+        if (child._parentUnlinkFn) {
+          child._parentUnlinkFn()
+        }
+        child.$destroy()
+      }
+      this.cache = null
+    }
+  }
+
+}

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

@@ -0,0 +1,13 @@
+module.exports = {
+
+  isLiteral: true,
+
+  bind: function () {
+    this.vm.$$[this.expression] = this.el
+  },
+
+  unbind: function () {
+    delete this.vm.$$[this.expression]
+  }
+  
+}

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

@@ -1,41 +1,37 @@
-var utils = require('../utils'),
-    slice = [].slice
+var _ = require('../util')
+var templateParser = require('../parsers/template')
 
-/**
- *  Binding for innerHTML
- */
 module.exports = {
 
-    bind: function () {
-        // a comment node means this is a binding for
-        // {{{ inline unescaped html }}}
-        if (this.el.nodeType === 8) {
-            // hold nodes
-            this.nodes = []
-        }
-    },
+  bind: function () {
+    // a comment node means this is a binding for
+    // {{{ inline unescaped html }}}
+    if (this.el.nodeType === 8) {
+      // hold nodes
+      this.nodes = []
+    }
+  },
 
-    update: function (value) {
-        value = utils.guard(value)
-        if (this.nodes) {
-            this.swap(value)
-        } else {
-            this.el.innerHTML = value
-        }
-    },
+  update: function (value) {
+    value = _.toString(value)
+    if (this.nodes) {
+      this.swap(value)
+    } else {
+      this.el.innerHTML = value
+    }
+  },
 
-    swap: function (value) {
-        var parent = this.el.parentNode,
-            nodes  = this.nodes,
-            i      = nodes.length
-        // remove old nodes
-        while (i--) {
-            parent.removeChild(nodes[i])
-        }
-        // convert new value to a fragment
-        var frag = utils.toFragment(value)
-        // save a reference to these nodes so we can remove later
-        this.nodes = slice.call(frag.childNodes)
-        parent.insertBefore(frag, this.el)
+  swap: function (value) {
+    // remove old nodes
+    var i = this.nodes.length
+    while (i--) {
+      _.remove(this.nodes[i])
     }
+    // convert new value to a fragment
+    var frag = templateParser.parse(value, true)
+    // save a reference to these nodes so we can remove later
+    this.nodes = _.toArray(frag.childNodes)
+    _.before(frag, this.el)
+  }
+
 }

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

@@ -1,56 +1,87 @@
-var utils    = require('../utils')
+var _ = require('../util')
+var compile = require('../compiler/compile')
+var templateParser = require('../parsers/template')
+var transition = require('../transition')
 
-/**
- *  Manages a conditional child VM
- */
 module.exports = {
 
-    bind: function () {
-        
-        this.parent = this.el.parentNode
-        this.ref    = document.createComment('vue-if')
-        this.Ctor   = this.compiler.resolveComponent(this.el)
-
-        // insert ref
-        this.parent.insertBefore(this.ref, this.el)
-        this.parent.removeChild(this.el)
+  bind: function () {
+    var el = this.el
+    if (!el.__vue__) {
+      this.start = document.createComment('v-if-start')
+      this.end = document.createComment('v-if-end')
+      _.replace(el, this.end)
+      _.before(this.start, this.end)
+      if (el.tagName === 'TEMPLATE') {
+        this.template = templateParser.parse(el, true)
+      } else {
+        this.template = document.createDocumentFragment()
+        this.template.appendChild(el)
+      }
+      // compile the nested partial
+      this.linker = compile(
+        this.template,
+        this.vm.$options,
+        true
+      )
+    } else {
+      this.invalid = true
+      _.warn(
+        'v-if="' + this.expression + '" cannot be ' +
+        'used on an already mounted instance.'
+      )
+    }
+  },
 
-        if (utils.attr(this.el, 'view')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-view. ' +
-                'Just set v-view\'s binding value to empty string to empty it.'
-            )
-        }
-        if (utils.attr(this.el, 'repeat')) {
-            utils.warn(
-                'Conflict: v-if cannot be used together with v-repeat. ' +
-                'Use `v-show` or the `filterBy` filter instead.'
-            )
-        }
-    },
+  update: function (value) {
+    if (this.invalid) return
+    if (value) {
+      this.insert()
+    } else {
+      this.teardown()
+    }
+  },
 
-    update: function (value) {
+  insert: function () {
+    // avoid duplicate inserts, since update() can be
+    // called with different truthy values
+    if (!this.unlink) {
+      this.compile(this.template) 
+    }
+  },
 
-        if (!value) {
-            this.unbind()
-        } else if (!this.childVM) {
-            this.childVM = new this.Ctor({
-                el: this.el.cloneNode(true),
-                parent: this.vm
-            })
-            if (this.compiler.init) {
-                this.parent.insertBefore(this.childVM.$el, this.ref)
-            } else {
-                this.childVM.$before(this.ref)
-            }
-        }
-        
-    },
+  compile: function (template) {
+    var vm = this.vm
+    var frag = templateParser.clone(template)
+    var originalChildLength = vm._children
+      ? vm._children.length
+      : 0
+    this.unlink = this.linker
+      ? this.linker(vm, frag)
+      : vm.$compile(frag)
+    transition.blockAppend(frag, this.end, vm)
+    this.children = vm._children
+      ? vm._children.slice(originalChildLength)
+      : null
+    if (this.children && _.inDoc(vm.$el)) {
+      this.children.forEach(function (child) {
+        child._callHook('attached')
+      })
+    }
+  },
 
-    unbind: function () {
-        if (this.childVM) {
-            this.childVM.$destroy()
-            this.childVM = null
+  teardown: function () {
+    if (!this.unlink) return
+    transition.blockRemove(this.start, this.end, this.vm)
+    if (this.children && _.inDoc(this.vm.$el)) {
+      this.children.forEach(function (child) {
+        if (!child._isDestroyed) {
+          child._callHook('detached')
         }
+      })
     }
+    this.unlink()
+    this.unlink = null
+  }
+
 }