fluentd-ui 0.3.8 → 0.3.9

data/vendor/assets/javascripts/bower/vue/src/api/global.js

@@ -0,0 +1,146 @@
+var _ = require('../util')
+var mergeOptions = require('../util/merge-option')
+
+/**
+ * Expose useful internals
+ */
+
+exports.util = _
+exports.nextTick = _.nextTick
+exports.config = require('../config')
+
+exports.compiler = {
+  compile: require('../compiler/compile'),
+  transclude: require('../compiler/transclude')
+}
+
+exports.parsers = {
+  path: require('../parsers/path'),
+  text: require('../parsers/text'),
+  template: require('../parsers/template'),
+  directive: require('../parsers/directive'),
+  expression: require('../parsers/expression')
+}
+
+/**
+ * Each instance constructor, including Vue, has a unique
+ * cid. This enables us to create wrapped "child
+ * constructors" for prototypal inheritance and cache them.
+ */
+
+exports.cid = 0
+var cid = 1
+
+/**
+ * Class inehritance
+ *
+ * @param {Object} extendOptions
+ */
+
+exports.extend = function (extendOptions) {
+  extendOptions = extendOptions || {}
+  var Super = this
+  var Sub = createClass(extendOptions.name || 'VueComponent')
+  Sub.prototype = Object.create(Super.prototype)
+  Sub.prototype.constructor = Sub
+  Sub.cid = cid++
+  Sub.options = mergeOptions(
+    Super.options,
+    extendOptions
+  )
+  Sub['super'] = Super
+  // allow further extension
+  Sub.extend = Super.extend
+  // create asset registers, so extended classes
+  // can have their private assets too.
+  createAssetRegisters(Sub)
+  return Sub
+}
+
+/**
+ * A function that returns a sub-class constructor with the
+ * given name. This gives us much nicer output when
+ * logging instances in the console.
+ *
+ * @param {String} name
+ * @return {Function}
+ */
+
+function createClass (name) {
+  return new Function(
+    'return function ' + _.camelize(name, true) +
+    ' (options) { this._init(options) }'
+  )()
+}
+
+/**
+ * Plugin system
+ *
+ * @param {Object} plugin
+ */
+
+exports.use = function (plugin) {
+  // additional parameters
+  var args = _.toArray(arguments, 1)
+  args.unshift(this)
+  if (typeof plugin.install === 'function') {
+    plugin.install.apply(plugin, args)
+  } else {
+    plugin.apply(null, args)
+  }
+  return this
+}
+
+/**
+ * Define asset registration methods on a constructor.
+ *
+ * @param {Function} Constructor
+ */
+
+var assetTypes = [
+  'directive',
+  'filter',
+  'partial',
+  'transition'
+]
+
+function createAssetRegisters (Constructor) {
+
+  /* Asset registration methods share the same signature:
+   *
+   * @param {String} id
+   * @param {*} definition
+   */
+
+  assetTypes.forEach(function (type) {
+    Constructor[type] = function (id, definition) {
+      if (!definition) {
+        return this.options[type + 's'][id]
+      } else {
+        this.options[type + 's'][id] = definition
+      }
+    }
+  })
+
+  /**
+   * Component registration needs to automatically invoke
+   * Vue.extend on object values.
+   *
+   * @param {String} id
+   * @param {Object|Function} definition
+   */
+
+  Constructor.component = function (id, definition) {
+    if (!definition) {
+      return this.options.components[id]
+    } else {
+      if (_.isPlainObject(definition)) {
+        definition.name = id
+        definition = _.Vue.extend(definition)
+      }
+      this.options.components[id] = definition
+    }
+  }
+}
+
+createAssetRegisters(exports)

data/vendor/assets/javascripts/bower/vue/src/api/lifecycle.js

@@ -0,0 +1,144 @@
+var _ = require('../util')
+var compile = require('../compiler/compile')
+
+/**
+ * Set instance target element and kick off the compilation
+ * process. The passed in `el` can be a selector string, an
+ * existing Element, or a DocumentFragment (for block
+ * instances).
+ *
+ * @param {Element|DocumentFragment|string} el
+ * @public
+ */
+
+exports.$mount = function (el) {
+  if (this._isCompiled) {
+    _.warn('$mount() should be called only once.')
+    return
+  }
+  if (!el) {
+    el = document.createElement('div')
+  } else if (typeof el === 'string') {
+    var selector = el
+    el = document.querySelector(el)
+    if (!el) {
+      _.warn('Cannot find element: ' + selector)
+      return
+    }
+  }
+  this._compile(el)
+  this._isCompiled = true
+  this._callHook('compiled')
+  if (_.inDoc(this.$el)) {
+    this._callHook('attached')
+    this._initDOMHooks()
+    ready.call(this)
+  } else {
+    this._initDOMHooks()
+    this.$once('hook:attached', ready)
+  }
+  return this
+}
+
+/**
+ * Mark an instance as ready.
+ */
+
+function ready () {
+  this._isAttached = true
+  this._isReady = true
+  this._callHook('ready')
+}
+
+/**
+ * Teardown an instance, unobserves the data, unbind all the
+ * directives, turn off all the event listeners, etc.
+ *
+ * @param {Boolean} remove - whether to remove the DOM node.
+ * @param {Boolean} deferCleanup - if true, defer cleanup to
+ *                                 be called later
+ * @public
+ */
+
+exports.$destroy = function (remove, deferCleanup) {
+  if (this._isBeingDestroyed) {
+    return
+  }
+  this._callHook('beforeDestroy')
+  this._isBeingDestroyed = true
+  var i
+  // remove self from parent. only necessary
+  // if parent is not being destroyed as well.
+  var parent = this.$parent
+  if (parent && !parent._isBeingDestroyed) {
+    i = parent._children.indexOf(this)
+    parent._children.splice(i, 1)
+  }
+  // destroy all children.
+  if (this._children) {
+    i = this._children.length
+    while (i--) {
+      this._children[i].$destroy()
+    }
+  }
+  // teardown all directives. this also tearsdown all
+  // directive-owned watchers.
+  i = this._directives.length
+  while (i--) {
+    this._directives[i]._teardown()
+  }
+  // teardown all user watchers.
+  for (i in this._userWatchers) {
+    this._userWatchers[i].teardown()
+  }
+  // remove reference to self on $el
+  if (this.$el) {
+    this.$el.__vue__ = null
+  }
+  // remove DOM element
+  var self = this
+  if (remove && this.$el) {
+    this.$remove(function () {
+      self._cleanup()
+    })
+  } else if (!deferCleanup) {
+    this._cleanup()
+  }
+}
+
+/**
+ * Clean up to ensure garbage collection.
+ * This is called after the leave transition if there
+ * is any.
+ */
+
+exports._cleanup = function () {
+  // remove reference from data ob
+  this._data.__ob__.removeVm(this)
+  this._data =
+  this._watchers =
+  this._userWatchers =
+  this._watcherList =
+  this.$el =
+  this.$parent =
+  this.$root =
+  this._children =
+  this._directives = null
+  // call the last hook...
+  this._isDestroyed = true
+  this._callHook('destroyed')
+  // turn off all instance listeners.
+  this.$off()
+}
+
+/**
+ * Partially compile a piece of DOM and return a
+ * decompile function.
+ *
+ * @param {Element|DocumentFragment} el
+ * @return {Function}
+ */
+
+exports.$compile = function (el) {
+  return compile(el, this.$options, true)(this, el)
+}

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

@@ -1,45 +1,65 @@
-var utils = require('./utils')
+var _ = require('./util')
+
+/**
+ * The Batcher maintains a job queue to be run
+ * async on the next event loop.
+ */
 
 function Batcher () {
-    this.reset()
+  this.reset()
 }
 
-var BatcherProto = Batcher.prototype
-
-BatcherProto.push = function (job) {
-    if (!job.id || !this.has[job.id]) {
-        this.queue.push(job)
-        this.has[job.id] = job
-        if (!this.waiting) {
-            this.waiting = true
-            utils.nextTick(utils.bind(this.flush, this))
-        }
-    } else if (job.override) {
-        var oldJob = this.has[job.id]
-        oldJob.cancelled = true
-        this.queue.push(job)
-        this.has[job.id] = job
+var p = Batcher.prototype
+
+/**
+ * Push a job into the job queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ *
+ * @param {Object} job
+ *   properties:
+ *   - {String|Number} id
+ *   - {Function}      run
+ */
+
+p.push = function (job) {
+  if (!job.id || !this.has[job.id] || this.flushing) {
+    this.queue.push(job)
+    this.has[job.id] = job
+    if (!this.waiting) {
+      this.waiting = true
+      _.nextTick(this.flush, this)
     }
+  }
 }
 
-BatcherProto.flush = function () {
-    // before flush hook
-    if (this._preFlush) this._preFlush()
-    // do not cache length because more jobs might be pushed
-    // as we execute existing jobs
-    for (var i = 0; i < this.queue.length; i++) {
-        var job = this.queue[i]
-        if (!job.cancelled) {
-            job.execute()
-        }
+/**
+ * Flush the queue and run the jobs.
+ * Will call a preFlush hook if has one.
+ */
+
+p.flush = function () {
+  this.flushing = true
+  // do not cache length because more jobs might be pushed
+  // as we run existing jobs
+  for (var i = 0; i < this.queue.length; i++) {
+    var job = this.queue[i]
+    if (!job.cancelled) {
+      job.run()
     }
-    this.reset()
+  }
+  this.reset()
 }
 
-BatcherProto.reset = function () {
-    this.has = utils.hash()
-    this.queue = []
-    this.waiting = false
+/**
+ * Reset the batcher's state.
+ */
+
+p.reset = function () {
+  this.has = {}
+  this.queue = []
+  this.waiting = false
+  this.flushing = false
 }
 
 module.exports = Batcher

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

@@ -0,0 +1,112 @@
+/**
+ * A doubly linked list-based Least Recently Used (LRU)
+ * cache. Will keep most recently used items while
+ * discarding least recently used items when its limit is
+ * reached. This is a bare-bone version of
+ * Rasmus Andersson's js-lru:
+ *
+ *   https://github.com/rsms/js-lru
+ *
+ * @param {Number} limit
+ * @constructor
+ */
+
+function Cache (limit) {
+  this.size = 0
+  this.limit = limit
+  this.head = this.tail = undefined
+  this._keymap = {}
+}
+
+var p = Cache.prototype
+
+/**
+ * Put <value> into the cache associated with <key>.
+ * Returns the entry which was removed to make room for
+ * the new entry. Otherwise undefined is returned.
+ * (i.e. if there was enough room already).
+ *
+ * @param {String} key
+ * @param {*} value
+ * @return {Entry|undefined}
+ */
+
+p.put = function (key, value) {
+  var entry = {
+    key:key,
+    value:value
+  }
+  this._keymap[key] = entry
+  if (this.tail) {
+    this.tail.newer = entry
+    entry.older = this.tail
+  } else {
+    this.head = entry
+  }
+  this.tail = entry
+  if (this.size === this.limit) {
+    return this.shift()
+  } else {
+    this.size++
+  }
+}
+
+/**
+ * Purge the least recently used (oldest) entry from the
+ * cache. Returns the removed entry or undefined if the
+ * cache was empty.
+ */
+
+p.shift = function () {
+  var entry = this.head
+  if (entry) {
+    this.head = this.head.newer
+    this.head.older = undefined
+    entry.newer = entry.older = undefined
+    this._keymap[entry.key] = undefined
+  }
+  return entry
+}
+
+/**
+ * Get and register recent use of <key>. Returns the value
+ * associated with <key> or undefined if not in cache.
+ *
+ * @param {String} key
+ * @param {Boolean} returnEntry
+ * @return {Entry|*}
+ */
+
+p.get = function (key, returnEntry) {
+  var entry = this._keymap[key]
+  if (entry === undefined) return
+  if (entry === this.tail) {
+    return returnEntry
+      ? entry
+      : entry.value
+  }
+  // HEAD--------------TAIL
+  //   <.older   .newer>
+  //  <--- add direction --
+  //   A  B  C  <D>  E
+  if (entry.newer) {
+    if (entry === this.head) {
+      this.head = entry.newer
+    }
+    entry.newer.older = entry.older // C <-- E.
+  }
+  if (entry.older) {
+    entry.older.newer = entry.newer // C. --> E
+  }
+  entry.newer = undefined // D --x
+  entry.older = this.tail // D. --> E
+  if (this.tail) {
+    this.tail.newer = entry // E. <-- D
+  }
+  this.tail = entry
+  return returnEntry
+    ? entry
+    : entry.value
+}
+
+module.exports = Cache