statixite 1.0.0

data/vendor/assets/bower_components/vue/src/directives/el.js

@@ -0,0 +1,12 @@
+module.exports = {
+
+  isLiteral: true,
+
+  bind: function () {
+    this.vm.$$[this.expression] = this.el
+  },
+
+  unbind: function () {
+    delete this.vm.$$[this.expression]
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/html.js

@@ -0,0 +1,40 @@
+var _ = require('../util')
+var templateParser = require('../parsers/template')
+
+module.exports = {
+
+  bind: function () {
+    // a comment node means this is a binding for
+    // {{{ inline unescaped html }}}
+    if (this.el.nodeType === 8) {
+      // hold nodes
+      this.nodes = []
+      // replace the placeholder with proper anchor
+      this.anchor = _.createAnchor('v-html')
+      _.replace(this.el, this.anchor)
+    }
+  },
+
+  update: function (value) {
+    value = _.toString(value)
+    if (this.nodes) {
+      this.swap(value)
+    } else {
+      this.el.innerHTML = value
+    }
+  },
+
+  swap: function (value) {
+    // remove old nodes
+    var i = this.nodes.length
+    while (i--) {
+      _.remove(this.nodes[i])
+    }
+    // convert new value to a fragment
+    // do not attempt to retrieve from id selector
+    var frag = templateParser.parse(value, true, true)
+    // save a reference to these nodes so we can remove later
+    this.nodes = _.toArray(frag.childNodes)
+    _.before(frag, this.anchor)
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/if.js

@@ -0,0 +1,125 @@
+var _ = require('../util')
+var compiler = require('../compiler')
+var templateParser = require('../parsers/template')
+var transition = require('../transition')
+var Cache = require('../cache')
+var cache = new Cache(1000)
+
+module.exports = {
+
+  bind: function () {
+    var el = this.el
+    if (!el.__vue__) {
+      this.start = _.createAnchor('v-if-start')
+      this.end = _.createAnchor('v-if-end')
+      _.replace(el, this.end)
+      _.before(this.start, this.end)
+      if (_.isTemplate(el)) {
+        this.template = templateParser.parse(el, true)
+      } else {
+        this.template = document.createDocumentFragment()
+        this.template.appendChild(templateParser.clone(el))
+      }
+      // compile the nested partial
+      var cacheId = (this.vm.constructor.cid || '') + el.outerHTML
+      this.linker = cache.get(cacheId)
+      if (!this.linker) {
+        this.linker = compiler.compile(
+          this.template,
+          this.vm.$options,
+          true // partial
+        )
+        cache.put(cacheId, this.linker)
+      }
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'v-if="' + this.expression + '" cannot be ' +
+        'used on an instance root element.'
+      )
+      this.invalid = true
+    }
+  },
+
+  update: function (value) {
+    if (this.invalid) return
+    if (value) {
+      // avoid duplicate compiles, since update() can be
+      // called with different truthy values
+      if (!this.unlink) {
+        this.link(
+          templateParser.clone(this.template),
+          this.linker
+        )
+      }
+    } else {
+      this.teardown()
+    }
+  },
+
+  link: function (frag, linker) {
+    var vm = this.vm
+    this.unlink = linker(vm, frag, this._host /* important */)
+    transition.blockAppend(frag, this.end, vm)
+    // call attached for all the child components created
+    // during the compilation
+    if (_.inDoc(vm.$el)) {
+      var children = this.getContainedComponents()
+      if (children) children.forEach(callAttach)
+    }
+  },
+
+  teardown: function () {
+    if (!this.unlink) return
+    // collect children beforehand
+    var children
+    if (_.inDoc(this.vm.$el)) {
+      children = this.getContainedComponents()
+    }
+    transition.blockRemove(this.start, this.end, this.vm)
+    if (children) children.forEach(callDetach)
+    this.unlink()
+    this.unlink = null
+  },
+
+  getContainedComponents: function () {
+    var vm = this._host || this.vm
+    var start = this.start.nextSibling
+    var end = this.end
+
+    function contains (c) {
+      var cur = start
+      var next
+      while (next !== end) {
+        next = cur.nextSibling
+        if (
+          cur === c.$el ||
+          cur.contains && cur.contains(c.$el)
+        ) {
+          return true
+        }
+        cur = next
+      }
+      return false
+    }
+
+    return vm.$children.length &&
+      vm.$children.filter(contains)
+  },
+
+  unbind: function () {
+    if (this.unlink) this.unlink()
+  }
+
+}
+
+function callAttach (child) {
+  if (!child._isAttached) {
+    child._callHook('attached')
+  }
+}
+
+function callDetach (child) {
+  if (child._isAttached) {
+    child._callHook('detached')
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/index.js

@@ -0,0 +1,24 @@
+// manipulation directives
+exports.text = require('./text')
+exports.html = require('./html')
+exports.attr = require('./attr')
+exports.show = require('./show')
+exports['class'] = require('./class')
+exports.el = require('./el')
+exports.ref = require('./ref')
+exports.cloak = require('./cloak')
+exports.style = require('./style')
+exports.transition = require('./transition')
+
+// event listener directives
+exports.on = require('./on')
+exports.model = require('./model')
+
+// logic control directives
+exports.repeat = require('./repeat')
+exports['if'] = require('./if')
+
+// internal directives that should not be used directly
+// but we still want to expose them for advanced usage.
+exports._component = require('./component')
+exports._prop = require('./prop')

data/vendor/assets/bower_components/vue/src/directives/model/checkbox.js

@@ -0,0 +1,42 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    var trueExp = this._checkParam('true-exp')
+    var falseExp = this._checkParam('false-exp')
+
+    this._matchValue = function (value) {
+      if (trueExp !== null) {
+        return _.looseEqual(value, self.vm.$eval(trueExp))
+      } else {
+        return !!value
+      }
+    }
+
+    function getValue () {
+      var val = el.checked
+      if (val && trueExp !== null) {
+        val = self.vm.$eval(trueExp)
+      }
+      if (!val && falseExp !== null) {
+        val = self.vm.$eval(falseExp)
+      }
+      return val
+    }
+
+    this.on('change', function () {
+      self.set(getValue())
+    })
+
+    if (el.checked) {
+      this._initValue = getValue()
+    }
+  },
+
+  update: function (value) {
+    this.el.checked = this._matchValue(value)
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/model/index.js

@@ -0,0 +1,82 @@
+var _ = require('../../util')
+
+var handlers = {
+  text: require('./text'),
+  radio: require('./radio'),
+  select: require('./select'),
+  checkbox: require('./checkbox')
+}
+
+module.exports = {
+
+  priority: 800,
+  twoWay: true,
+  handlers: handlers,
+
+  /**
+   * Possible elements:
+   *   <select>
+   *   <textarea>
+   *   <input type="*">
+   *     - text
+   *     - checkbox
+   *     - radio
+   *     - number
+   *     - TODO: more types may be supplied as a plugin
+   */
+
+  bind: function () {
+    // friendly warning...
+    this.checkFilters()
+    if (this.hasRead && !this.hasWrite) {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'It seems you are using a read-only filter with ' +
+        'v-model. You might want to use a two-way filter ' +
+        'to ensure correct behavior.'
+      )
+    }
+    var el = this.el
+    var tag = el.tagName
+    var handler
+    if (tag === 'INPUT') {
+      handler = handlers[el.type] || handlers.text
+    } else if (tag === 'SELECT') {
+      handler = handlers.select
+    } else if (tag === 'TEXTAREA') {
+      handler = handlers.text
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'v-model does not support element type: ' + tag
+      )
+      return
+    }
+    el.__v_model = this
+    handler.bind.call(this)
+    this.update = handler.update
+    this._unbind = handler.unbind
+  },
+
+  /**
+   * Check read/write filter stats.
+   */
+
+  checkFilters: function () {
+    var filters = this.filters
+    if (!filters) return
+    var i = filters.length
+    while (i--) {
+      var filter = _.resolveAsset(this.vm.$options, 'filters', filters[i].name)
+      if (typeof filter === 'function' || filter.read) {
+        this.hasRead = true
+      }
+      if (filter.write) {
+        this.hasWrite = true
+      }
+    }
+  },
+
+  unbind: function () {
+    this.el.__v_model = null
+    this._unbind && this._unbind()
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/model/radio.js

@@ -0,0 +1,33 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    var number = this._checkParam('number') != null
+    var expression = this._checkParam('exp')
+
+    this.getValue = function () {
+      var val = el.value
+      if (number) {
+        val = _.toNumber(val)
+      } else if (expression !== null) {
+        val = self.vm.$eval(expression)
+      }
+      return val
+    }
+
+    this.on('change', function () {
+      self.set(self.getValue())
+    })
+
+    if (el.checked) {
+      this._initValue = this.getValue()
+    }
+  },
+
+  update: function (value) {
+    this.el.checked = _.looseEqual(value, this.getValue())
+  }
+}

data/vendor/assets/bower_components/vue/src/directives/model/select.js

@@ -0,0 +1,236 @@
+var _ = require('../../util')
+var Watcher = require('../../watcher')
+var dirParser = require('../../parsers/directive')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+
+    // method to force update DOM using latest value.
+    this.forceUpdate = function () {
+      if (self._watcher) {
+        self.update(self._watcher.get())
+      }
+    }
+
+    // check options param
+    var optionsParam = this._checkParam('options')
+    if (optionsParam) {
+      initOptions.call(this, optionsParam)
+    }
+    this.number = this._checkParam('number') != null
+    this.multiple = el.hasAttribute('multiple')
+
+    // attach listener
+    this.on('change', function () {
+      var value = getValue(el, self.multiple)
+      value = self.number
+        ? _.isArray(value)
+          ? value.map(_.toNumber)
+          : _.toNumber(value)
+        : value
+      self.set(value)
+    })
+
+    // check initial value (inline selected attribute)
+    checkInitialValue.call(this)
+
+    // All major browsers except Firefox resets
+    // selectedIndex with value -1 to 0 when the element
+    // is appended to a new parent, therefore we have to
+    // force a DOM update whenever that happens...
+    this.vm.$on('hook:attached', this.forceUpdate)
+  },
+
+  update: function (value) {
+    var el = this.el
+    el.selectedIndex = -1
+    if (value == null) {
+      if (this.defaultOption) {
+        this.defaultOption.selected = true
+      }
+      return
+    }
+    var multi = this.multiple && _.isArray(value)
+    var options = el.options
+    var i = options.length
+    var op, val
+    while (i--) {
+      op = options[i]
+      val = op.hasOwnProperty('_value')
+        ? op._value
+        : op.value
+      /* eslint-disable eqeqeq */
+      op.selected = multi
+        ? indexOf(value, val) > -1
+        : _.looseEqual(value, val)
+      /* eslint-enable eqeqeq */
+    }
+  },
+
+  unbind: function () {
+    this.vm.$off('hook:attached', this.forceUpdate)
+    if (this.optionWatcher) {
+      this.optionWatcher.teardown()
+    }
+  }
+}
+
+/**
+ * Initialize the option list from the param.
+ *
+ * @param {String} expression
+ */
+
+function initOptions (expression) {
+  var self = this
+  var el = self.el
+  var defaultOption = self.defaultOption = self.el.options[0]
+  var descriptor = dirParser.parse(expression)[0]
+  function optionUpdateWatcher (value) {
+    if (_.isArray(value)) {
+      // clear old options.
+      // cannot reset innerHTML here because IE family get
+      // confused during compilation.
+      var i = el.options.length
+      while (i--) {
+        var option = el.options[i]
+        if (option !== defaultOption) {
+          var parentNode = option.parentNode
+          if (parentNode === el) {
+            parentNode.removeChild(option)
+          } else {
+            el.removeChild(parentNode)
+            i = el.options.length
+          }
+        }
+      }
+      buildOptions(el, value)
+      self.forceUpdate()
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Invalid options value for v-model: ' + value
+      )
+    }
+  }
+  this.optionWatcher = new Watcher(
+    this.vm,
+    descriptor.expression,
+    optionUpdateWatcher,
+    {
+      deep: true,
+      filters: descriptor.filters
+    }
+  )
+  // update with initial value
+  optionUpdateWatcher(this.optionWatcher.value)
+}
+
+/**
+ * Build up option elements. IE9 doesn't create options
+ * when setting innerHTML on <select> elements, so we have
+ * to use DOM API here.
+ *
+ * @param {Element} parent - a <select> or an <optgroup>
+ * @param {Array} options
+ */
+
+function buildOptions (parent, options) {
+  var op, el
+  for (var i = 0, l = options.length; i < l; i++) {
+    op = options[i]
+    if (!op.options) {
+      el = document.createElement('option')
+      if (typeof op === 'string' || typeof op === 'number') {
+        el.text = el.value = op
+      } else {
+        if (op.value != null && !_.isObject(op.value)) {
+          el.value = op.value
+        }
+        // object values gets serialized when set as value,
+        // so we store the raw value as a different property
+        el._value = op.value
+        el.text = op.text || ''
+        if (op.disabled) {
+          el.disabled = true
+        }
+      }
+    } else {
+      el = document.createElement('optgroup')
+      el.label = op.label
+      buildOptions(el, op.options)
+    }
+    parent.appendChild(el)
+  }
+}
+
+/**
+ * Check the initial value for selected options.
+ */
+
+function checkInitialValue () {
+  var initValue
+  var options = this.el.options
+  for (var i = 0, l = options.length; i < l; i++) {
+    if (options[i].hasAttribute('selected')) {
+      if (this.multiple) {
+        (initValue || (initValue = []))
+          .push(options[i].value)
+      } else {
+        initValue = options[i].value
+      }
+    }
+  }
+  if (typeof initValue !== 'undefined') {
+    this._initValue = this.number
+      ? _.toNumber(initValue)
+      : initValue
+  }
+}
+
+/**
+ * Get select value
+ *
+ * @param {SelectElement} el
+ * @param {Boolean} multi
+ * @return {Array|*}
+ */
+
+function getValue (el, multi) {
+  var res = multi ? [] : null
+  var op, val
+  for (var i = 0, l = el.options.length; i < l; i++) {
+    op = el.options[i]
+    if (op.selected) {
+      val = op.hasOwnProperty('_value')
+        ? op._value
+        : op.value
+      if (multi) {
+        res.push(val)
+      } else {
+        return val
+      }
+    }
+  }
+  return res
+}
+
+/**
+ * Native Array.indexOf uses strict equal, but in this
+ * case we need to match string/numbers with custom equal.
+ *
+ * @param {Array} arr
+ * @param {*} val
+ */
+
+function indexOf (arr, val) {
+  var i = arr.length
+  while (i--) {
+    if (_.looseEqual(arr[i], val)) {
+      return i
+    }
+  }
+  return -1
+}