fluentd-ui 0.1.0

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

@@ -0,0 +1,174 @@
+var utils = require('../utils'),
+    isIE9 = navigator.userAgent.indexOf('MSIE 9.0') > 0,
+    filter = [].filter
+
+/**
+ *  Returns an array of values from a multiple select
+ */
+function getMultipleSelectOptions (select) {
+    return filter
+        .call(select.options, function (option) {
+            return option.selected
+        })
+        .map(function (option) {
+            return option.value || option.text
+        })
+}
+
+/**
+ *  Two-way binding for form input elements
+ */
+module.exports = {
+
+    bind: function () {
+
+        var self = this,
+            el   = self.el,
+            type = el.type,
+            tag  = el.tagName
+
+        self.lock = false
+        self.ownerVM = self.binding.compiler.vm
+
+        // determine what event to listen to
+        self.event =
+            (self.compiler.options.lazy ||
+            tag === 'SELECT' ||
+            type === 'checkbox' || type === 'radio')
+                ? 'change'
+                : 'input'
+
+        // determine the attribute to change when updating
+        self.attr = type === 'checkbox'
+            ? 'checked'
+            : (tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA')
+                ? 'value'
+                : 'innerHTML'
+
+        // select[multiple] support
+        if(tag === 'SELECT' && el.hasAttribute('multiple')) {
+            this.multi = true
+        }
+
+        var compositionLock = false
+        self.cLock = function () {
+            compositionLock = true
+        }
+        self.cUnlock = function () {
+            compositionLock = false
+        }
+        el.addEventListener('compositionstart', this.cLock)
+        el.addEventListener('compositionend', this.cUnlock)
+
+        // attach listener
+        self.set = self.filters
+            ? function () {
+                if (compositionLock) return
+                // if this directive has filters
+                // we need to let the vm.$set trigger
+                // update() so filters are applied.
+                // therefore we have to record cursor position
+                // so that after vm.$set changes the input
+                // value we can put the cursor back at where it is
+                var cursorPos
+                try { cursorPos = el.selectionStart } catch (e) {}
+
+                self._set()
+
+                // since updates are async
+                // we need to reset cursor position async too
+                utils.nextTick(function () {
+                    if (cursorPos !== undefined) {
+                        el.setSelectionRange(cursorPos, cursorPos)
+                    }
+                })
+            }
+            : function () {
+                if (compositionLock) return
+                // no filters, don't let it trigger update()
+                self.lock = true
+
+                self._set()
+
+                utils.nextTick(function () {
+                    self.lock = false
+                })
+            }
+        el.addEventListener(self.event, self.set)
+
+        // fix shit for IE9
+        // since it doesn't fire input on backspace / del / cut
+        if (isIE9) {
+            self.onCut = function () {
+                // cut event fires before the value actually changes
+                utils.nextTick(function () {
+                    self.set()
+                })
+            }
+            self.onDel = function (e) {
+                if (e.keyCode === 46 || e.keyCode === 8) {
+                    self.set()
+                }
+            }
+            el.addEventListener('cut', self.onCut)
+            el.addEventListener('keyup', self.onDel)
+        }
+    },
+
+    _set: function () {
+        this.ownerVM.$set(
+            this.key, this.multi
+                ? getMultipleSelectOptions(this.el)
+                : this.el[this.attr]
+        )
+    },
+
+    update: function (value, init) {
+        /* jshint eqeqeq: false */
+        // sync back inline value if initial data is undefined
+        if (init && value === undefined) {
+            return this._set()
+        }
+        if (this.lock) return
+        var el = this.el
+        if (el.tagName === 'SELECT') { // select dropdown
+            el.selectedIndex = -1
+            if(this.multi && Array.isArray(value)) {
+                value.forEach(this.updateSelect, this)
+            } else {
+                this.updateSelect(value)
+            }
+        } else if (el.type === 'radio') { // radio button
+            el.checked = value == el.value
+        } else if (el.type === 'checkbox') { // checkbox
+            el.checked = !!value
+        } else {
+            el[this.attr] = utils.guard(value)
+        }
+    },
+
+    updateSelect: function (value) {
+        /* jshint eqeqeq: false */
+        // setting <select>'s value in IE9 doesn't work
+        // we have to manually loop through the options
+        var options = this.el.options,
+            i = options.length
+        while (i--) {
+            if (options[i].value == value) {
+                options[i].selected = true
+                break
+            }
+        }
+    },
+
+    unbind: function () {
+        var el = this.el
+        el.removeEventListener(this.event, this.set)
+        el.removeEventListener('compositionstart', this.cLock)
+        el.removeEventListener('compositionend', this.cUnlock)
+        if (isIE9) {
+            el.removeEventListener('cut', this.onCut)
+            el.removeEventListener('keyup', this.onDel)
+        }
+    }
+}

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

@@ -0,0 +1,56 @@
+var utils    = require('../utils')
+
+/**
+ *  Binding for event listeners
+ */
+module.exports = {
+
+    isFn: true,
+
+    bind: function () {
+        this.context = this.binding.isExp
+            ? this.vm
+            : this.binding.compiler.vm
+        if (this.el.tagName === 'IFRAME' && this.arg !== 'load') {
+            var self = this
+            this.iframeBind = function () {
+                self.el.contentWindow.addEventListener(self.arg, self.handler)
+            }
+            this.el.addEventListener('load', this.iframeBind)
+        }
+    },
+
+    update: function (handler) {
+        if (typeof handler !== 'function') {
+            utils.warn('Directive "v-on:' + this.expression + '" expects a method.')
+            return
+        }
+        this.reset()
+        var vm = this.vm,
+            context = this.context
+        this.handler = function (e) {
+            e.targetVM = vm
+            context.$event = e
+            var res = handler.call(context, e)
+            context.$event = null
+            return res
+        }
+        if (this.iframeBind) {
+            this.iframeBind()
+        } else {
+            this.el.addEventListener(this.arg, this.handler)
+        }
+    },
+
+    reset: function () {
+        var el = this.iframeBind
+            ? this.el.contentWindow
+            : this.el
+        el.removeEventListener(this.arg, this.handler)
+    },
+
+    unbind: function () {
+        this.reset()
+        this.el.removeEventListener('load', this.iframeBind)
+    }
+}

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

@@ -0,0 +1,50 @@
+var utils = require('../utils')
+
+/**
+ *  Binding for partials
+ */
+module.exports = {
+
+    isLiteral: true,
+
+    bind: function () {
+
+        var id = this.expression
+        if (!id) return
+
+        var el       = this.el,
+            compiler = this.compiler,
+            partial  = compiler.getOption('partials', id)
+
+        if (!partial) {
+            if (id === 'yield') {
+                utils.warn('{{>yield}} syntax has been deprecated. Use <content> tag instead.')
+            }
+            return
+        }
+
+        partial = partial.cloneNode(true)
+
+        // comment ref node means inline partial
+        if (el.nodeType === 8) {
+
+            // keep a ref for the partial's content nodes
+            var nodes = [].slice.call(partial.childNodes),
+                parent = el.parentNode
+            parent.insertBefore(partial, el)
+            parent.removeChild(el)
+            // compile partial after appending, because its children's parentNode
+            // will change from the fragment to the correct parentNode.
+            // This could affect directives that need access to its element's parentNode.
+            nodes.forEach(compiler.compile, compiler)
+
+        } else {
+
+            // just set innerHTML...
+            el.innerHTML = ''
+            el.appendChild(partial)
+
+        }
+    }
+
+}

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

@@ -0,0 +1,246 @@
+var utils      = require('../utils'),
+    config     = require('../config')
+
+/**
+ *  Binding that manages VMs based on an Array
+ */
+module.exports = {
+
+    bind: function () {
+
+        this.identifier = '$r' + this.id
+
+        // a hash to cache the same expressions on repeated instances
+        // so they don't have to be compiled for every single instance
+        this.expCache = utils.hash()
+
+        var el   = this.el,
+            ctn  = this.container = el.parentNode
+
+        // extract child Id, if any
+        this.childId = this.compiler.eval(utils.attr(el, 'ref'))
+
+        // create a comment node as a reference node for DOM insertions
+        this.ref = document.createComment(config.prefix + '-repeat-' + this.key)
+        ctn.insertBefore(this.ref, el)
+        ctn.removeChild(el)
+
+        this.collection = null
+        this.vms = null
+
+    },
+
+    update: function (collection) {
+
+        if (!Array.isArray(collection)) {
+            if (utils.isObject(collection)) {
+                collection = utils.objectToArray(collection)
+            } else {
+                utils.warn('v-repeat only accepts Array or Object values.')
+            }
+        }
+
+        // keep reference of old data and VMs
+        // so we can reuse them if possible
+        this.oldVMs = this.vms
+        this.oldCollection = this.collection
+        collection = this.collection = collection || []
+
+        var isObject = collection[0] && utils.isObject(collection[0])
+        this.vms = this.oldCollection
+            ? this.diff(collection, isObject)
+            : this.init(collection, isObject)
+
+        if (this.childId) {
+            this.vm.$[this.childId] = this.vms
+        }
+
+    },
+
+    init: function (collection, isObject) {
+        var vm, vms = []
+        for (var i = 0, l = collection.length; i < l; i++) {
+            vm = this.build(collection[i], i, isObject)
+            vms.push(vm)
+            if (this.compiler.init) {
+                this.container.insertBefore(vm.$el, this.ref)
+            } else {
+                vm.$before(this.ref)
+            }
+        }
+        return vms
+    },
+
+    /**
+     *  Diff the new array with the old
+     *  and determine the minimum amount of DOM manipulations.
+     */
+    diff: function (newCollection, isObject) {
+
+        var i, l, item, vm,
+            oldIndex,
+            targetNext,
+            currentNext,
+            nextEl,
+            ctn    = this.container,
+            oldVMs = this.oldVMs,
+            vms    = []
+
+        vms.length = newCollection.length
+
+        // first pass, collect new reused and new created
+        for (i = 0, l = newCollection.length; i < l; i++) {
+            item = newCollection[i]
+            if (isObject) {
+                item.$index = i
+                if (item.__emitter__ && item.__emitter__[this.identifier]) {
+                    // this piece of data is being reused.
+                    // record its final position in reused vms
+                    item.$reused = true
+                } else {
+                    vms[i] = this.build(item, i, isObject)
+                }
+            } else {
+                // we can't attach an identifier to primitive values
+                // so have to do an indexOf...
+                oldIndex = indexOf(oldVMs, item)
+                if (oldIndex > -1) {
+                    // record the position on the existing vm
+                    oldVMs[oldIndex].$reused = true
+                    oldVMs[oldIndex].$data.$index = i
+                } else {
+                    vms[i] = this.build(item, i, isObject)
+                }
+            }
+        }
+
+        // second pass, collect old reused and destroy unused
+        for (i = 0, l = oldVMs.length; i < l; i++) {
+            vm = oldVMs[i]
+            item = this.arg
+                ? vm.$data[this.arg]
+                : vm.$data
+            if (item.$reused) {
+                vm.$reused = true
+                delete item.$reused
+            }
+            if (vm.$reused) {
+                // update the index to latest
+                vm.$index = item.$index
+                // the item could have had a new key
+                if (item.$key && item.$key !== vm.$key) {
+                    vm.$key = item.$key
+                }
+                vms[vm.$index] = vm
+            } else {
+                // this one can be destroyed.
+                if (item.__emitter__) {
+                    delete item.__emitter__[this.identifier]
+                }
+                vm.$destroy()
+            }
+        }
+
+        // final pass, move/insert DOM elements
+        i = vms.length
+        while (i--) {
+            vm = vms[i]
+            item = vm.$data
+            targetNext = vms[i + 1]
+            if (vm.$reused) {
+                nextEl = vm.$el.nextSibling
+                // destroyed VMs' element might still be in the DOM
+                // due to transitions
+                while (!nextEl.vue_vm && nextEl !== this.ref) {
+                    nextEl = nextEl.nextSibling
+                }
+                currentNext = nextEl.vue_vm
+                if (currentNext !== targetNext) {
+                    if (!targetNext) {
+                        ctn.insertBefore(vm.$el, this.ref)
+                    } else {
+                        nextEl = targetNext.$el
+                        // new VMs' element might not be in the DOM yet
+                        // due to transitions
+                        while (!nextEl.parentNode) {
+                            targetNext = vms[nextEl.vue_vm.$index + 1]
+                            nextEl = targetNext
+                                ? targetNext.$el
+                                : this.ref
+                        }
+                        ctn.insertBefore(vm.$el, nextEl)
+                    }
+                }
+                delete vm.$reused
+                delete item.$index
+                delete item.$key
+            } else { // a new vm
+                vm.$before(targetNext ? targetNext.$el : this.ref)
+            }
+        }
+
+        return vms
+    },
+
+    build: function (data, index, isObject) {
+
+        // wrap non-object values
+        var raw, alias,
+            wrap = !isObject || this.arg
+        if (wrap) {
+            raw = data
+            alias = this.arg || '$value'
+            data = {}
+            data[alias] = raw
+        }
+        data.$index = index
+
+        var el = this.el.cloneNode(true),
+            Ctor = this.compiler.resolveComponent(el, data),
+            vm = new Ctor({
+                el: el,
+                data: data,
+                parent: this.vm,
+                compilerOptions: {
+                    repeat: true,
+                    expCache: this.expCache
+                }
+            })
+
+        if (isObject) {
+            // attach an ienumerable identifier to the raw data
+            (raw || data).__emitter__[this.identifier] = true
+        }
+
+        return vm
+
+    },
+
+    unbind: function () {
+        if (this.childId) {
+            delete this.vm.$[this.childId]
+        }
+        if (this.vms) {
+            var i = this.vms.length
+            while (i--) {
+                this.vms[i].$destroy()
+            }
+        }
+    }
+}
+
+// Helpers --------------------------------------------------------------------
+
+/**
+ *  Find an object or a wrapped data object
+ *  from an Array
+ */
+function indexOf (vms, obj) {
+    for (var vm, i = 0, l = vms.length; i < l; i++) {
+        vm = vms[i]
+        if (!vm.$reused && vm.$value === obj) {
+            return i
+        }
+    }
+    return -1
+}