fluentd-ui 0.3.13 → 0.3.14

data/vendor/assets/javascripts/bower/vue/src/parsers/template.js

@@ -1,248 +0,0 @@
-var _ = require('../util')
-var Cache = require('../cache')
-var templateCache = new Cache(1000)
-var idSelectorCache = new Cache(1000)
-
-var map = {
-  _default : [0, '', ''],
-  legend   : [1, '<fieldset>', '</fieldset>'],
-  tr       : [2, '<table><tbody>', '</tbody></table>'],
-  col      : [
-    2,
-    '<table><tbody></tbody><colgroup>',
-    '</colgroup></table>'
-  ]
-}
-
-map.td =
-map.th = [
-  3,
-  '<table><tbody><tr>',
-  '</tr></tbody></table>'
-]
-
-map.option =
-map.optgroup = [
-  1,
-  '<select multiple="multiple">',
-  '</select>'
-]
-
-map.thead =
-map.tbody =
-map.colgroup =
-map.caption =
-map.tfoot = [1, '<table>', '</table>']
-
-map.g =
-map.defs =
-map.symbol =
-map.use =
-map.image =
-map.text =
-map.circle =
-map.ellipse =
-map.line =
-map.path =
-map.polygon =
-map.polyline =
-map.rect = [
-  1,
-  '<svg ' +
-    'xmlns="http://www.w3.org/2000/svg" ' +
-    'xmlns:xlink="http://www.w3.org/1999/xlink" ' +
-    'xmlns:ev="http://www.w3.org/2001/xml-events"' +
-    'version="1.1">',
-  '</svg>'
-]
-
-var TAG_RE = /<([\w:]+)/
-
-/**
- * Convert a string template to a DocumentFragment.
- * Determines correct wrapping by tag types. Wrapping
- * strategy found in jQuery & component/domify.
- *
- * @param {String} templateString
- * @return {DocumentFragment}
- */
-
-function stringToFragment (templateString) {
-  // try a cache hit first
-  var hit = templateCache.get(templateString)
-  if (hit) {
-    return hit
-  }
-
-  var frag = document.createDocumentFragment()
-  var tagMatch = TAG_RE.exec(templateString)
-
-  if (!tagMatch) {
-    // text only, return a single text node.
-    frag.appendChild(
-      document.createTextNode(templateString)
-    )
-  } else {
-
-    var tag    = tagMatch[1]
-    var wrap   = map[tag] || map._default
-    var depth  = wrap[0]
-    var prefix = wrap[1]
-    var suffix = wrap[2]
-    var node   = document.createElement('div')
-
-    node.innerHTML = prefix + templateString.trim() + suffix
-    while (depth--) {
-      node = node.lastChild
-    }
-
-    var child
-    /* jshint boss:true */
-    while (child = node.firstChild) {
-      frag.appendChild(child)
-    }
-  }
-
-  templateCache.put(templateString, frag)
-  return frag
-}
-
-/**
- * Convert a template node to a DocumentFragment.
- *
- * @param {Node} node
- * @return {DocumentFragment}
- */
-
-function nodeToFragment (node) {
-  var tag = node.tagName
-  // if its a template tag and the browser supports it,
-  // its content is already a document fragment.
-  if (
-    tag === 'TEMPLATE' &&
-    node.content instanceof DocumentFragment
-  ) {
-    return node.content
-  }
-  return tag === 'SCRIPT'
-    ? stringToFragment(node.textContent)
-    : stringToFragment(node.innerHTML)
-}
-
-// Test for the presence of the Safari template cloning bug
-// https://bugs.webkit.org/show_bug.cgi?id=137755
-var hasBrokenTemplate = _.inBrowser
-  ? (function () {
-      var a = document.createElement('div')
-      a.innerHTML = '<template>1</template>'
-      return !a.cloneNode(true).firstChild.innerHTML
-    })()
-  : false
-
-// Test for IE10/11 textarea placeholder clone bug
-var hasTextareaCloneBug = _.inBrowser
-  ? (function () {
-      var t = document.createElement('textarea')
-      t.placeholder = 't'
-      return t.cloneNode(true).value === 't'
-    })()
-  : false
-
-/**
- * 1. Deal with Safari cloning nested <template> bug by
- *    manually cloning all template instances.
- * 2. Deal with IE10/11 textarea placeholder bug by setting
- *    the correct value after cloning.
- *
- * @param {Element|DocumentFragment} node
- * @return {Element|DocumentFragment}
- */
-
-exports.clone = function (node) {
-  var res = node.cloneNode(true)
-  var i, original, cloned
-  /* istanbul ignore if */
-  if (hasBrokenTemplate) {
-    original = node.querySelectorAll('template')
-    if (original.length) {
-      cloned = res.querySelectorAll('template')
-      i = cloned.length
-      while (i--) {
-        cloned[i].parentNode.replaceChild(
-          original[i].cloneNode(true),
-          cloned[i]
-        )
-      }
-    }
-  }
-  /* istanbul ignore if */
-  if (hasTextareaCloneBug) {
-    if (node.tagName === 'TEXTAREA') {
-      res.value = node.value
-    } else {
-      original = node.querySelectorAll('textarea')
-      if (original.length) {
-        cloned = res.querySelectorAll('textarea')
-        i = cloned.length
-        while (i--) {
-          cloned[i].value = original[i].value
-        }
-      }
-    }
-  }
-  return res
-}
-
-/**
- * Process the template option and normalizes it into a
- * a DocumentFragment that can be used as a partial or a
- * instance template.
- *
- * @param {*} template
- *    Possible values include:
- *    - DocumentFragment object
- *    - Node object of type Template
- *    - id selector: '#some-template-id'
- *    - template string: '<div><span>{{msg}}</span></div>'
- * @param {Boolean} clone
- * @param {Boolean} noSelector
- * @return {DocumentFragment|undefined}
- */
-
-exports.parse = function (template, clone, noSelector) {
-  var node, frag
-
-  // if the template is already a document fragment,
-  // do nothing
-  if (template instanceof DocumentFragment) {
-    return clone
-      ? template.cloneNode(true)
-      : template
-  }
-
-  if (typeof template === 'string') {
-    // id selector
-    if (!noSelector && template.charAt(0) === '#') {
-      // id selector can be cached too
-      frag = idSelectorCache.get(template)
-      if (!frag) {
-        node = document.getElementById(template.slice(1))
-        if (node) {
-          frag = nodeToFragment(node)
-          // save selector to cache
-          idSelectorCache.put(template, frag)
-        }
-      }
-    } else {
-      // normal string template
-      frag = stringToFragment(template)
-    }
-  } else if (template.nodeType) {
-    // a direct node
-    frag = nodeToFragment(template)
-  }
-
-  return frag && clone
-    ? exports.clone(frag)
-    : frag
-}

data/vendor/assets/javascripts/bower/vue/src/parsers/text.js

@@ -1,178 +0,0 @@
-var Cache = require('../cache')
-var config = require('../config')
-var dirParser = require('./directive')
-var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
-var cache, tagRE, htmlRE, firstChar, lastChar
-
-/**
- * Escape a string so it can be used in a RegExp
- * constructor.
- *
- * @param {String} str
- */
-
-function escapeRegex (str) {
-  return str.replace(regexEscapeRE, '\\$&')
-}
-
-/**
- * Compile the interpolation tag regex.
- *
- * @return {RegExp}
- */
-
-function compileRegex () {
-  config._delimitersChanged = false
-  var open = config.delimiters[0]
-  var close = config.delimiters[1]
-  firstChar = open.charAt(0)
-  lastChar = close.charAt(close.length - 1)
-  var firstCharRE = escapeRegex(firstChar)
-  var lastCharRE = escapeRegex(lastChar)
-  var openRE = escapeRegex(open)
-  var closeRE = escapeRegex(close)
-  tagRE = new RegExp(
-    firstCharRE + '?' + openRE +
-    '(.+?)' +
-    closeRE + lastCharRE + '?',
-    'g'
-  )
-  htmlRE = new RegExp(
-    '^' + firstCharRE + openRE +
-    '.*' +
-    closeRE + lastCharRE + '$'
-  )
-  // reset cache
-  cache = new Cache(1000)
-}
-
-/**
- * Parse a template text string into an array of tokens.
- *
- * @param {String} text
- * @return {Array<Object> | null}
- *               - {String} type
- *               - {String} value
- *               - {Boolean} [html]
- *               - {Boolean} [oneTime]
- */
-
-exports.parse = function (text) {
-  if (config._delimitersChanged) {
-    compileRegex()
-  }
-  var hit = cache.get(text)
-  if (hit) {
-    return hit
-  }
-  if (!tagRE.test(text)) {
-    return null
-  }
-  var tokens = []
-  var lastIndex = tagRE.lastIndex = 0
-  var match, index, value, first, oneTime, partial
-  /* jshint boss:true */
-  while (match = tagRE.exec(text)) {
-    index = match.index
-    // push text token
-    if (index > lastIndex) {
-      tokens.push({
-        value: text.slice(lastIndex, index)
-      })
-    }
-    // tag token
-    first = match[1].charCodeAt(0)
-    oneTime = first === 0x2A // *
-    partial = first === 0x3E // >
-    value = (oneTime || partial)
-      ? match[1].slice(1)
-      : match[1]
-    tokens.push({
-      tag: true,
-      value: value.trim(),
-      html: htmlRE.test(match[0]),
-      oneTime: oneTime,
-      partial: partial
-    })
-    lastIndex = index + match[0].length
-  }
-  if (lastIndex < text.length) {
-    tokens.push({
-      value: text.slice(lastIndex)
-    })
-  }
-  cache.put(text, tokens)
-  return tokens
-}
-
-/**
- * Format a list of tokens into an expression.
- * e.g. tokens parsed from 'a {{b}} c' can be serialized
- * into one single expression as '"a " + b + " c"'.
- *
- * @param {Array} tokens
- * @param {Vue} [vm]
- * @return {String}
- */
-
-exports.tokensToExp = function (tokens, vm) {
-  return tokens.length > 1
-    ? tokens.map(function (token) {
-        return formatToken(token, vm)
-      }).join('+')
-    : formatToken(tokens[0], vm, true)
-}
-
-/**
- * Format a single token.
- *
- * @param {Object} token
- * @param {Vue} [vm]
- * @param {Boolean} single
- * @return {String}
- */
-
-function formatToken (token, vm, single) {
-  return token.tag
-    ? vm && token.oneTime
-      ? '"' + vm.$eval(token.value) + '"'
-      : single
-        ? token.value
-        : inlineFilters(token.value)
-    : '"' + token.value + '"'
-}
-
-/**
- * For an attribute with multiple interpolation tags,
- * e.g. attr="some-{{thing | filter}}", in order to combine
- * the whole thing into a single watchable expression, we
- * have to inline those filters. This function does exactly
- * that. This is a bit hacky but it avoids heavy changes
- * to directive parser and watcher mechanism.
- *
- * @param {String} exp
- * @return {String}
- */
-
-var filterRE = /[^|]\|[^|]/
-function inlineFilters (exp) {
-  if (!filterRE.test(exp)) {
-    return '(' + exp + ')'
-  } else {
-    var dir = dirParser.parse(exp)[0]
-    if (!dir.filters) {
-      return '(' + exp + ')'
-    } else {
-      exp = dir.expression
-      for (var i = 0, l = dir.filters.length; i < l; i++) {
-        var filter = dir.filters[i]
-        var args = filter.args
-          ? ',"' + filter.args.join('","') + '"'
-          : ''
-        exp = 'this.$options.filters["' + filter.name + '"]' +
-          '.apply(this,[' + exp + args + '])'
-      }
-      return exp
-    }
-  }
-}

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

@@ -1,189 +0,0 @@
-var _ = require('../util')
-var addClass = _.addClass
-var removeClass = _.removeClass
-var transDurationProp = _.transitionProp + 'Duration'
-var animDurationProp = _.animationProp + 'Duration'
-
-var queue = []
-var queued = false
-
-/**
- * Push a job into the transition queue, which is to be
- * executed on next frame.
- *
- * @param {Element} el    - target element
- * @param {Number} dir    - 1: enter, -1: leave
- * @param {Function} op   - the actual dom operation
- * @param {String} cls    - the className to remove when the
- *                          transition is done.
- * @param {Function} [cb] - user supplied callback.
- */
-
-function push (el, dir, op, cls, cb) {
-  queue.push({
-    el  : el,
-    dir : dir,
-    cb  : cb,
-    cls : cls,
-    op  : op
-  })
-  if (!queued) {
-    queued = true
-    _.nextTick(flush)
-  }
-}
-
-/**
- * Flush the queue, and do one forced reflow before
- * triggering transitions.
- */
-
-function flush () {
-  /* jshint unused: false */
-  var f = document.documentElement.offsetHeight
-  queue.forEach(run)
-  queue = []
-  queued = false
-}
-
-/**
- * Run a transition job.
- *
- * @param {Object} job
- */
-
-function run (job) {
-
-  var el = job.el
-  var data = el.__v_trans
-  var cls = job.cls
-  var cb = job.cb
-  var op = job.op
-  var transitionType = getTransitionType(el, data, cls)
-
-  if (job.dir > 0) { // ENTER
-    if (transitionType === 1) {
-      // trigger transition by removing enter class
-      removeClass(el, cls)
-      // only need to listen for transitionend if there's
-      // a user callback
-      if (cb) setupTransitionCb(_.transitionEndEvent)
-    } else if (transitionType === 2) {
-      // animations are triggered when class is added
-      // so we just listen for animationend to remove it.
-      setupTransitionCb(_.animationEndEvent, function () {
-        removeClass(el, cls)
-      })
-    } else {
-      // no transition applicable
-      removeClass(el, cls)
-      if (cb) cb()
-    }
-  } else { // LEAVE
-    if (transitionType) {
-      // leave transitions/animations are both triggered
-      // by adding the class, just remove it on end event.
-      var event = transitionType === 1
-        ? _.transitionEndEvent
-        : _.animationEndEvent
-      setupTransitionCb(event, function () {
-        op()
-        removeClass(el, cls)
-      })
-    } else {
-      op()
-      removeClass(el, cls)
-      if (cb) cb()
-    }
-  }
-
-  /**
-   * Set up a transition end callback, store the callback
-   * on the element's __v_trans data object, so we can
-   * clean it up if another transition is triggered before
-   * the callback is fired.
-   *
-   * @param {String} event
-   * @param {Function} [cleanupFn]
-   */
-
-  function setupTransitionCb (event, cleanupFn) {
-    data.event = event
-    var onEnd = data.callback = function transitionCb (e) {
-      if (e.target === el) {
-        _.off(el, event, onEnd)
-        data.event = data.callback = null
-        if (cleanupFn) cleanupFn()
-        if (cb) cb()
-      }
-    }
-    _.on(el, event, onEnd)
-  }
-}
-
-/**
- * Get an element's transition type based on the
- * calculated styles
- *
- * @param {Element} el
- * @param {Object} data
- * @param {String} className
- * @return {Number}
- *         1 - transition
- *         2 - animation
- */
-
-function getTransitionType (el, data, className) {
-  var type = data.cache && data.cache[className]
-  if (type) return type
-  var inlineStyles = el.style
-  var computedStyles = window.getComputedStyle(el)
-  var transDuration =
-    inlineStyles[transDurationProp] ||
-    computedStyles[transDurationProp]
-  if (transDuration && transDuration !== '0s') {
-    type = 1
-  } else {
-    var animDuration =
-      inlineStyles[animDurationProp] ||
-      computedStyles[animDurationProp]
-    if (animDuration && animDuration !== '0s') {
-      type = 2
-    }
-  }
-  if (type) {
-    if (!data.cache) data.cache = {}
-    data.cache[className] = type
-  }
-  return type
-}
-
-/**
- * Apply CSS transition to an element.
- *
- * @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
- */
-
-module.exports = function (el, direction, op, data, cb) {
-  var prefix = data.id || 'v'
-  var enterClass = prefix + '-enter'
-  var leaveClass = prefix + '-leave'
-  // clean up potential previous unfinished transition
-  if (data.callback) {
-    _.off(el, data.event, data.callback)
-    removeClass(el, enterClass)
-    removeClass(el, leaveClass)
-    data.event = data.callback = null
-  }
-  if (direction > 0) { // enter
-    addClass(el, enterClass)
-    op()
-    push(el, direction, null, enterClass, cb)
-  } else { // leave
-    addClass(el, leaveClass)
-    push(el, direction, op, leaveClass, cb)
-  }
-}