fluentd-ui 0.3.8 → 0.3.9

data/vendor/assets/javascripts/bower/vue/src/template-parser.js

@@ -1,46 +0,0 @@
-var toFragment = require('./fragment');
-
-/**
- * Parses a template string or node and normalizes it into a
- * a node that can be used as a partial of a template option
- *
- * Possible values include
- * id selector: '#some-template-id'
- * template string: '<div><span>my template</span></div>'
- * DocumentFragment object
- * Node object of type Template
- */
-module.exports = function(template) {
-    var templateNode;
-
-    if (template instanceof window.DocumentFragment) {
-        // if the template is already a document fragment -- do nothing
-        return template
-    }
-
-    if (typeof template === 'string') {
-        // template by ID
-        if (template.charAt(0) === '#') {
-            templateNode = document.getElementById(template.slice(1))
-            if (!templateNode) return
-        } else {
-            return toFragment(template)
-        }
-    } else if (template.nodeType) {
-        templateNode = template
-    } else {
-        return
-    }
-
-    // if its a template tag and the browser supports it,
-    // its content is already a document fragment!
-    if (templateNode.tagName === 'TEMPLATE' && templateNode.content) {
-        return templateNode.content
-    }
-
-    if (templateNode.tagName === 'SCRIPT') {
-        return toFragment(templateNode.innerHTML)
-    }
-
-    return toFragment(templateNode.outerHTML);
-}

data/vendor/assets/javascripts/bower/vue/src/text-parser.js

@@ -1,96 +0,0 @@
-var openChar        = '{',
-    endChar         = '}',
-    ESCAPE_RE       = /[-.*+?^${}()|[\]\/\\]/g,
-    // lazy require
-    Directive
-
-exports.Regex = buildInterpolationRegex()
-
-function buildInterpolationRegex () {
-    var open = escapeRegex(openChar),
-        end  = escapeRegex(endChar)
-    return new RegExp(open + open + open + '?(.+?)' + end + '?' + end + end)
-}
-
-function escapeRegex (str) {
-    return str.replace(ESCAPE_RE, '\\$&')
-}
-
-function setDelimiters (delimiters) {
-    openChar = delimiters[0]
-    endChar = delimiters[1]
-    exports.delimiters = delimiters
-    exports.Regex = buildInterpolationRegex()
-}
-
-/** 
- *  Parse a piece of text, return an array of tokens
- *  token types:
- *  1. plain string
- *  2. object with key = binding key
- *  3. object with key & html = true
- */
-function parse (text) {
-    if (!exports.Regex.test(text)) return null
-    var m, i, token, match, tokens = []
-    /* jshint boss: true */
-    while (m = text.match(exports.Regex)) {
-        i = m.index
-        if (i > 0) tokens.push(text.slice(0, i))
-        token = { key: m[1].trim() }
-        match = m[0]
-        token.html =
-            match.charAt(2) === openChar &&
-            match.charAt(match.length - 3) === endChar
-        tokens.push(token)
-        text = text.slice(i + m[0].length)
-    }
-    if (text.length) tokens.push(text)
-    return tokens
-}
-
-/**
- *  Parse an attribute value with possible interpolation tags
- *  return a Directive-friendly expression
- *
- *  e.g.  a {{b}} c  =>  "a " + b + " c"
- */
-function parseAttr (attr) {
-    Directive = Directive || require('./directive')
-    var tokens = parse(attr)
-    if (!tokens) return null
-    if (tokens.length === 1) return tokens[0].key
-    var res = [], token
-    for (var i = 0, l = tokens.length; i < l; i++) {
-        token = tokens[i]
-        res.push(
-            token.key
-                ? inlineFilters(token.key)
-                : ('"' + token + '"')
-        )
-    }
-    return res.join('+')
-}
-
-/**
- *  Inlines any possible filters in a binding
- *  so that we can combine everything into a huge expression
- */
-function inlineFilters (key) {
-    if (key.indexOf('|') > -1) {
-        var dirs = Directive.parse(key),
-            dir = dirs && dirs[0]
-        if (dir && dir.filters) {
-            key = Directive.inlineFilters(
-                dir.key,
-                dir.filters
-            )
-        }
-    }
-    return '(' + key + ')'
-}
-
-exports.parse         = parse
-exports.parseAttr     = parseAttr
-exports.setDelimiters = setDelimiters
-exports.delimiters    = [openChar, endChar]

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

@@ -1,228 +0,0 @@
-var endEvents  = sniffEndEvents(),
-    config     = require('./config'),
-    // batch enter animations so we only force the layout once
-    Batcher    = require('./batcher'),
-    batcher    = new Batcher(),
-    // cache timer functions
-    setTO      = window.setTimeout,
-    clearTO    = window.clearTimeout,
-    // exit codes for testing
-    codes = {
-        CSS_E     : 1,
-        CSS_L     : 2,
-        JS_E      : 3,
-        JS_L      : 4,
-        CSS_SKIP  : -1,
-        JS_SKIP   : -2,
-        JS_SKIP_E : -3,
-        JS_SKIP_L : -4,
-        INIT      : -5,
-        SKIP      : -6
-    }
-
-// force layout before triggering transitions/animations
-batcher._preFlush = function () {
-    /* jshint unused: false */
-    var f = document.body.offsetHeight
-}
-
-/**
- *  stage:
- *    1 = enter
- *    2 = leave
- */
-var transition = module.exports = function (el, stage, cb, compiler) {
-
-    var changeState = function () {
-        cb()
-        compiler.execHook(stage > 0 ? 'attached' : 'detached')
-    }
-
-    if (compiler.init) {
-        changeState()
-        return codes.INIT
-    }
-
-    var hasTransition = el.vue_trans === '',
-        hasAnimation  = el.vue_anim === '',
-        effectId      = el.vue_effect
-
-    if (effectId) {
-        return applyTransitionFunctions(
-            el,
-            stage,
-            changeState,
-            effectId,
-            compiler
-        )
-    } else if (hasTransition || hasAnimation) {
-        return applyTransitionClass(
-            el,
-            stage,
-            changeState,
-            hasAnimation
-        )
-    } else {
-        changeState()
-        return codes.SKIP
-    }
-
-}
-
-/**
- *  Togggle a CSS class to trigger transition
- */
-function applyTransitionClass (el, stage, changeState, hasAnimation) {
-
-    if (!endEvents.trans) {
-        changeState()
-        return codes.CSS_SKIP
-    }
-
-    // if the browser supports transition,
-    // it must have classList...
-    var onEnd,
-        classList        = el.classList,
-        existingCallback = el.vue_trans_cb,
-        enterClass       = config.enterClass,
-        leaveClass       = config.leaveClass,
-        endEvent         = hasAnimation ? endEvents.anim : endEvents.trans
-
-    // cancel unfinished callbacks and jobs
-    if (existingCallback) {
-        el.removeEventListener(endEvent, existingCallback)
-        classList.remove(enterClass)
-        classList.remove(leaveClass)
-        el.vue_trans_cb = null
-    }
-
-    if (stage > 0) { // enter
-
-        // set to enter state before appending
-        classList.add(enterClass)
-        // append
-        changeState()
-        // trigger transition
-        if (!hasAnimation) {
-            batcher.push({
-                execute: function () {
-                    classList.remove(enterClass)
-                }
-            })
-        } else {
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    classList.remove(enterClass)
-                }
-            }
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        }
-        return codes.CSS_E
-
-    } else { // leave
-
-        if (el.offsetWidth || el.offsetHeight) {
-            // trigger hide transition
-            classList.add(leaveClass)
-            onEnd = function (e) {
-                if (e.target === el) {
-                    el.removeEventListener(endEvent, onEnd)
-                    el.vue_trans_cb = null
-                    // actually remove node here
-                    changeState()
-                    classList.remove(leaveClass)
-                }
-            }
-            // attach transition end listener
-            el.addEventListener(endEvent, onEnd)
-            el.vue_trans_cb = onEnd
-        } else {
-            // directly remove invisible elements
-            changeState()
-        }
-        return codes.CSS_L
-        
-    }
-
-}
-
-function applyTransitionFunctions (el, stage, changeState, effectId, compiler) {
-
-    var funcs = compiler.getOption('effects', effectId)
-    if (!funcs) {
-        changeState()
-        return codes.JS_SKIP
-    }
-
-    var enter = funcs.enter,
-        leave = funcs.leave,
-        timeouts = el.vue_timeouts
-
-    // clear previous timeouts
-    if (timeouts) {
-        var i = timeouts.length
-        while (i--) {
-            clearTO(timeouts[i])
-        }
-    }
-
-    timeouts = el.vue_timeouts = []
-    function timeout (cb, delay) {
-        var id = setTO(function () {
-            cb()
-            timeouts.splice(timeouts.indexOf(id), 1)
-            if (!timeouts.length) {
-                el.vue_timeouts = null
-            }
-        }, delay)
-        timeouts.push(id)
-    }
-
-    if (stage > 0) { // enter
-        if (typeof enter !== 'function') {
-            changeState()
-            return codes.JS_SKIP_E
-        }
-        enter(el, changeState, timeout)
-        return codes.JS_E
-    } else { // leave
-        if (typeof leave !== 'function') {
-            changeState()
-            return codes.JS_SKIP_L
-        }
-        leave(el, changeState, timeout)
-        return codes.JS_L
-    }
-
-}
-
-/**
- *  Sniff proper transition end event name
- */
-function sniffEndEvents () {
-    var el = document.createElement('vue'),
-        defaultEvent = 'transitionend',
-        events = {
-            'webkitTransition' : 'webkitTransitionEnd',
-            'transition'       : defaultEvent,
-            'mozTransition'    : defaultEvent
-        },
-        ret = {}
-    for (var name in events) {
-        if (el.style[name] !== undefined) {
-            ret.trans = events[name]
-            break
-        }
-    }
-    ret.anim = el.style.animation === ''
-        ? 'animationend'
-        : 'webkitAnimationEnd'
-    return ret
-}
-
-// Expose some stuff for testing purposes
-transition.codes = codes
-transition.sniff = sniffEndEvents

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

@@ -1,326 +0,0 @@
-var config       = require('./config'),
-    toString     = ({}).toString,
-    win          = window,
-    console      = win.console,
-    def          = Object.defineProperty,
-    OBJECT       = 'object',
-    THIS_RE      = /[^\w]this[^\w]/,
-    BRACKET_RE_S = /\['([^']+)'\]/g,
-    BRACKET_RE_D = /\["([^"]+)"\]/g,
-    hasClassList = 'classList' in document.documentElement,
-    ViewModel // late def
-
-var defer =
-    win.requestAnimationFrame ||
-    win.webkitRequestAnimationFrame ||
-    win.setTimeout
-
-/**
- *  Normalize keypath with possible brackets into dot notations
- */
-function normalizeKeypath (key) {
-    return key.indexOf('[') < 0
-        ? key
-        : key.replace(BRACKET_RE_S, '.$1')
-             .replace(BRACKET_RE_D, '.$1')
-}
-
-var utils = module.exports = {
-
-    /**
-     *  Convert a string template to a dom fragment
-     */
-    toFragment: require('./fragment'),
-
-    /**
-     *  Parse the various types of template options
-     */
-    parseTemplateOption: require('./template-parser.js'),
-
-    /**
-     *  get a value from an object keypath
-     */
-    get: function (obj, key) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            return obj[key]
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length
-        while (++d < l && obj != null) {
-            obj = obj[path[d]]
-        }
-        return obj
-    },
-
-    /**
-     *  set a value to an object keypath
-     */
-    set: function (obj, key, val) {
-        /* jshint eqeqeq: false */
-        key = normalizeKeypath(key)
-        if (key.indexOf('.') < 0) {
-            obj[key] = val
-            return
-        }
-        var path = key.split('.'),
-            d = -1, l = path.length - 1
-        while (++d < l) {
-            if (obj[path[d]] == null) {
-                obj[path[d]] = {}
-            }
-            obj = obj[path[d]]
-        }
-        obj[path[d]] = val
-    },
-
-    /**
-     *  return the base segment of a keypath
-     */
-    baseKey: function (key) {
-        return key.indexOf('.') > 0
-            ? key.split('.')[0]
-            : key
-    },
-
-    /**
-     *  Create a prototype-less object
-     *  which is a better hash/map
-     */
-    hash: function () {
-        return Object.create(null)
-    },
-
-    /**
-     *  get an attribute and remove it.
-     */
-    attr: function (el, type) {
-        var attr = config.prefix + '-' + type,
-            val = el.getAttribute(attr)
-        if (val !== null) {
-            el.removeAttribute(attr)
-        }
-        return val
-    },
-
-    /**
-     *  Define an ienumerable property
-     *  This avoids it being included in JSON.stringify
-     *  or for...in loops.
-     */
-    defProtected: function (obj, key, val, enumerable, writable) {
-        def(obj, key, {
-            value        : val,
-            enumerable   : enumerable,
-            writable     : writable,
-            configurable : true
-        })
-    },
-
-    /**
-     *  A less bullet-proof but more efficient type check
-     *  than Object.prototype.toString
-     */
-    isObject: function (obj) {
-        return typeof obj === OBJECT && obj && !Array.isArray(obj)
-    },
-
-    /**
-     *  A more accurate but less efficient type check
-     */
-    isTrueObject: function (obj) {
-        return toString.call(obj) === '[object Object]'
-    },
-
-    /**
-     *  Most simple bind
-     *  enough for the usecase and fast than native bind()
-     */
-    bind: function (fn, ctx) {
-        return function (arg) {
-            return fn.call(ctx, arg)
-        }
-    },
-
-    /**
-     *  Make sure null and undefined output empty string
-     */
-    guard: function (value) {
-        /* jshint eqeqeq: false, eqnull: true */
-        return value == null
-            ? ''
-            : (typeof value == 'object')
-                ? JSON.stringify(value)
-                : value
-    },
-
-    /**
-     *  When setting value on the VM, parse possible numbers
-     */
-    checkNumber: function (value) {
-        return (isNaN(value) || value === null || typeof value === 'boolean')
-            ? value
-            : Number(value)
-    },
-
-    /**
-     *  simple extend
-     */
-    extend: function (obj, ext) {
-        for (var key in ext) {
-            if (obj[key] !== ext[key]) {
-                obj[key] = ext[key]
-            }
-        }
-        return obj
-    },
-
-    /**
-     *  filter an array with duplicates into uniques
-     */
-    unique: function (arr) {
-        var hash = utils.hash(),
-            i = arr.length,
-            key, res = []
-        while (i--) {
-            key = arr[i]
-            if (hash[key]) continue
-            hash[key] = 1
-            res.push(key)
-        }
-        return res
-    },
-
-    /**
-     *  Convert the object to a ViewModel constructor
-     *  if it is not already one
-     */
-    toConstructor: function (obj) {
-        ViewModel = ViewModel || require('./viewmodel')
-        return utils.isObject(obj)
-            ? ViewModel.extend(obj)
-            : typeof obj === 'function'
-                ? obj
-                : null
-    },
-
-    /**
-     *  Check if a filter function contains references to `this`
-     *  If yes, mark it as a computed filter.
-     */
-    checkFilter: function (filter) {
-        if (THIS_RE.test(filter.toString())) {
-            filter.computed = true
-        }
-    },
-
-    /**
-     *  convert certain option values to the desired format.
-     */
-    processOptions: function (options) {
-        var components = options.components,
-            partials   = options.partials,
-            template   = options.template,
-            filters    = options.filters,
-            key
-        if (components) {
-            for (key in components) {
-                components[key] = utils.toConstructor(components[key])
-            }
-        }
-        if (partials) {
-            for (key in partials) {
-                partials[key] = utils.parseTemplateOption(partials[key])
-            }
-        }
-        if (filters) {
-            for (key in filters) {
-                utils.checkFilter(filters[key])
-            }
-        }
-        if (template) {
-            options.template = utils.parseTemplateOption(template)
-        }
-    },
-
-    /**
-     *  used to defer batch updates
-     */
-    nextTick: function (cb) {
-        defer(cb, 0)
-    },
-
-    /**
-     *  add class for IE9
-     *  uses classList if available
-     */
-    addClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.add(cls)
-        } else {
-            var cur = ' ' + el.className + ' '
-            if (cur.indexOf(' ' + cls + ' ') < 0) {
-                el.className = (cur + cls).trim()
-            }
-        }
-    },
-
-    /**
-     *  remove class for IE9
-     */
-    removeClass: function (el, cls) {
-        if (hasClassList) {
-            el.classList.remove(cls)
-        } else {
-            var cur = ' ' + el.className + ' ',
-                tar = ' ' + cls + ' '
-            while (cur.indexOf(tar) >= 0) {
-                cur = cur.replace(tar, ' ')
-            }
-            el.className = cur.trim()
-        }
-    },
-
-    /**
-     *  Convert an object to Array
-     *  used in v-repeat and array filters
-     */
-    objectToArray: function (obj) {
-        var res = [], val, data
-        for (var key in obj) {
-            val = obj[key]
-            data = utils.isObject(val)
-                ? val
-                : { $value: val }
-            data.$key = key
-            res.push(data)
-        }
-        return res
-    }
-}
-
-enableDebug()
-function enableDebug () {
-    /**
-     *  log for debugging
-     */
-    utils.log = function (msg) {
-        if (config.debug && console) {
-            console.log(msg)
-        }
-    }
-    
-    /**
-     *  warnings, traces by default
-     *  can be suppressed by `silent` option.
-     */
-    utils.warn = function (msg) {
-        if (!config.silent && console) {
-            console.warn(msg)
-            if (config.debug && console.trace) {
-                console.trace()
-            }
-        }
-    }
-}