fluentd-ui 0.3.13 → 0.3.14

data/vendor/assets/javascripts/bower/vue/src/compiler/transclude.js

@@ -1,146 +0,0 @@
-var _ = require('../util')
-var templateParser = require('../parsers/template')
-
-/**
- * Process an element or a DocumentFragment based on a
- * instance option object. This allows us to transclude
- * a template node/fragment before the instance is created,
- * so the processed fragment can then be cloned and reused
- * in v-repeat.
- *
- * @param {Element} el
- * @param {Object} options
- * @return {Element|DocumentFragment}
- */
-
-module.exports = function transclude (el, options) {
-  // for template tags, what we want is its content as
-  // a documentFragment (for block instances)
-  if (el.tagName === 'TEMPLATE') {
-    el = templateParser.parse(el)
-  }
-  if (options && options.template) {
-    el = transcludeTemplate(el, options)
-  }
-  if (el instanceof DocumentFragment) {
-    _.prepend(document.createComment('v-start'), el)
-    el.appendChild(document.createComment('v-end'))
-  }
-  return el
-}
-
-/**
- * Process the template option.
- * If the replace option is true this will swap the $el.
- *
- * @param {Element} el
- * @param {Object} options
- * @return {Element|DocumentFragment}
- */
-
-function transcludeTemplate (el, options) {
-  var template = options.template
-  var frag = templateParser.parse(template, true)
-  if (!frag) {
-    _.warn('Invalid template option: ' + template)
-  } else {
-    var rawContent = options._content || _.extractContent(el)
-    if (options.replace) {
-      if (frag.childNodes.length > 1) {
-        transcludeContent(frag, rawContent)
-        return frag
-      } else {
-        var replacer = frag.firstChild
-        _.copyAttributes(el, replacer)
-        transcludeContent(replacer, rawContent)
-        return replacer
-      }
-    } else {
-      el.appendChild(frag)
-      transcludeContent(el, rawContent)
-      return el
-    }
-  }
-}
-
-/**
- * Resolve <content> insertion points mimicking the behavior
- * of the Shadow DOM spec:
- *
- *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
- *
- * @param {Element|DocumentFragment} el
- * @param {Element} raw
- */
-
-function transcludeContent (el, raw) {
-  var outlets = getOutlets(el)
-  var i = outlets.length
-  if (!i) return
-  var outlet, select, selected, j, main
-  // first pass, collect corresponding content
-  // for each outlet.
-  while (i--) {
-    outlet = outlets[i]
-    if (raw) {
-      select = outlet.getAttribute('select')
-      if (select) {  // select content
-        selected = raw.querySelectorAll(select)
-        outlet.content = _.toArray(
-          selected.length
-            ? selected
-            : outlet.childNodes
-        )
-      } else { // default content
-        main = outlet
-      }
-    } else { // fallback content
-      outlet.content = _.toArray(outlet.childNodes)
-    }
-  }
-  // second pass, actually insert the contents
-  for (i = 0, j = outlets.length; i < j; i++) {
-    outlet = outlets[i]
-    if (outlet !== main) {
-      insertContentAt(outlet, outlet.content)
-    }
-  }
-  // finally insert the main content
-  if (main) {
-    insertContentAt(main, _.toArray(raw.childNodes))
-  }
-}
-
-/**
- * Get <content> outlets from the element/list
- *
- * @param {Element|Array} el
- * @return {Array}
- */
-
-var concat = [].concat
-function getOutlets (el) {
-  return _.isArray(el)
-    ? concat.apply([], el.map(getOutlets))
-    : el.querySelectorAll
-      ? _.toArray(el.querySelectorAll('content'))
-      : []
-}
-
-/**
- * Insert an array of nodes at outlet,
- * then remove the outlet.
- *
- * @param {Element} outlet
- * @param {Array} contents
- */
-
-function insertContentAt (outlet, contents) {
-  // not using util DOM methods here because
-  // parentNode can be cached
-  var parent = outlet.parentNode
-  for (var i = 0, j = contents.length; i < j; i++) {
-    parent.insertBefore(contents[i], outlet)
-  }
-  parent.removeChild(outlet)
-}

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

@@ -1,79 +0,0 @@
-module.exports = {
-
-  /**
-   * The prefix to look for when parsing directives.
-   *
-   * @type {String}
-   */
-
-  prefix: 'v-',
-
-  /**
-   * Whether to print debug messages.
-   * Also enables stack trace for warnings.
-   *
-   * @type {Boolean}
-   */
-
-  debug: false,
-
-  /**
-   * Whether to suppress warnings.
-   *
-   * @type {Boolean}
-   */
-
-  silent: false,
-
-  /**
-   * Whether allow observer to alter data objects'
-   * __proto__.
-   *
-   * @type {Boolean}
-   */
-
-  proto: true,
-
-  /**
-   * Whether to parse mustache tags in templates.
-   *
-   * @type {Boolean}
-   */
-
-  interpolate: true,
-
-  /**
-   * Whether to use async rendering.
-   */
-
-  async: true,
-
-  /**
-   * Internal flag to indicate the delimiters have been
-   * changed.
-   *
-   * @type {Boolean}
-   */
-
-  _delimitersChanged: true
-
-}
-
-/**
- * Interpolation delimiters.
- * We need to mark the changed flag so that the text parser
- * knows it needs to recompile the regex.
- *
- * @type {Array<String>}
- */
-
-var delimiters = ['{{', '}}']
-Object.defineProperty(module.exports, 'delimiters', {
-  get: function () {
-    return delimiters
-  },
-  set: function (val) {
-    delimiters = val
-    this._delimitersChanged = true
-  }
-})

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

@@ -1,219 +0,0 @@
-var _ = require('./util')
-var config = require('./config')
-var Watcher = require('./watcher')
-var textParser = require('./parsers/text')
-var expParser = require('./parsers/expression')
-
-/**
- * A directive links a DOM element with a piece of data,
- * which is the result of evaluating an expression.
- * It registers a watcher with the expression and calls
- * the DOM update function when a change is triggered.
- *
- * @param {String} name
- * @param {Node} el
- * @param {Vue} vm
- * @param {Object} descriptor
- *                 - {String} expression
- *                 - {String} [arg]
- *                 - {Array<Object>} [filters]
- * @param {Object} def - directive definition object
- * @constructor
- */
-
-function Directive (name, el, vm, descriptor, def) {
-  // public
-  this.name = name
-  this.el = el
-  this.vm = vm
-  // copy descriptor props
-  this.raw = descriptor.raw
-  this.expression = descriptor.expression
-  this.arg = descriptor.arg
-  this.filters = _.resolveFilters(vm, descriptor.filters)
-  // private
-  this._locked = false
-  this._bound = false
-  // init
-  this._bind(def)
-}
-
-var p = Directive.prototype
-
-/**
- * Initialize the directive, mixin definition properties,
- * setup the watcher, call definition bind() and update()
- * if present.
- *
- * @param {Object} def
- */
-
-p._bind = function (def) {
-  if (this.name !== 'cloak' && this.el.removeAttribute) {
-    this.el.removeAttribute(config.prefix + this.name)
-  }
-  if (typeof def === 'function') {
-    this.update = def
-  } else {
-    _.extend(this, def)
-  }
-  this._watcherExp = this.expression
-  this._checkDynamicLiteral()
-  if (this.bind) {
-    this.bind()
-  }
-  if (
-    this.update && this._watcherExp &&
-    (!this.isLiteral || this._isDynamicLiteral) &&
-    !this._checkStatement()
-  ) {
-    // wrapped updater for context
-    var dir = this
-    var update = this._update = function (val, oldVal) {
-      if (!dir._locked) {
-        dir.update(val, oldVal)
-      }
-    }
-    // use raw expression as identifier because filters
-    // make them different watchers
-    var watcher = this.vm._watchers[this.raw]
-    // v-repeat always creates a new watcher because it has
-    // a special filter that's bound to its directive
-    // instance.
-    if (!watcher || this.name === 'repeat') {
-      watcher = this.vm._watchers[this.raw] = new Watcher(
-        this.vm,
-        this._watcherExp,
-        update, // callback
-        this.filters,
-        this.twoWay, // need setter,
-        this.deep
-      )
-    } else {
-      watcher.addCb(update)
-    }
-    this._watcher = watcher
-    if (this._initValue != null) {
-      watcher.set(this._initValue)
-    } else {
-      this.update(watcher.value)
-    }
-  }
-  this._bound = true
-}
-
-/**
- * check if this is a dynamic literal binding.
- *
- * e.g. v-component="{{currentView}}"
- */
-
-p._checkDynamicLiteral = function () {
-  var expression = this.expression
-  if (expression && this.isLiteral) {
-    var tokens = textParser.parse(expression)
-    if (tokens) {
-      var exp = textParser.tokensToExp(tokens)
-      this.expression = this.vm.$get(exp)
-      this._watcherExp = exp
-      this._isDynamicLiteral = true
-    }
-  }
-}
-
-/**
- * Check if the directive is a function caller
- * and if the expression is a callable one. If both true,
- * we wrap up the expression and use it as the event
- * handler.
- *
- * e.g. v-on="click: a++"
- *
- * @return {Boolean}
- */
-
-p._checkStatement = function () {
-  var expression = this.expression
-  if (
-    expression && this.acceptStatement &&
-    !expParser.pathTestRE.test(expression)
-  ) {
-    var fn = expParser.parse(expression).get
-    var vm = this.vm
-    var handler = function () {
-      fn.call(vm, vm)
-    }
-    if (this.filters) {
-      handler = _.applyFilters(
-        handler,
-        this.filters.read,
-        vm
-      )
-    }
-    this.update(handler)
-    return true
-  }
-}
-
-/**
- * Check for an attribute directive param, e.g. lazy
- *
- * @param {String} name
- * @return {String}
- */
-
-p._checkParam = function (name) {
-  var param = this.el.getAttribute(name)
-  if (param !== null) {
-    this.el.removeAttribute(name)
-  }
-  return param
-}
-
-/**
- * Teardown the watcher and call unbind.
- */
-
-p._teardown = function () {
-  if (this._bound) {
-    if (this.unbind) {
-      this.unbind()
-    }
-    var watcher = this._watcher
-    if (watcher && watcher.active) {
-      watcher.removeCb(this._update)
-      if (!watcher.active) {
-        this.vm._watchers[this.raw] = null
-      }
-    }
-    this._bound = false
-    this.vm = this.el = this._watcher = null
-  }
-}
-
-/**
- * Set the corresponding value with the setter.
- * This should only be used in two-way directives
- * e.g. v-model.
- *
- * @param {*} value
- * @param {Boolean} lock - prevent wrtie triggering update.
- * @public
- */
-
-p.set = function (value, lock) {
-  if (this.twoWay) {
-    if (lock) {
-      this._locked = true
-    }
-    this._watcher.set(value)
-    if (lock) {
-      var self = this
-      _.nextTick(function () {
-        self._locked = false
-      })
-    }
-  }
-}
-
-module.exports = Directive

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

@@ -1,32 +0,0 @@
-// 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')
-  }
-}