statixite 1.0.0

data/vendor/assets/bower_components/vue/src/instance/init.js

@@ -0,0 +1,89 @@
+var mergeOptions = require('../util').mergeOptions
+
+/**
+ * The main init sequence. This is called for every
+ * instance, including ones that are created from extended
+ * constructors.
+ *
+ * @param {Object} options - this options object should be
+ *                           the result of merging class
+ *                           options and the options passed
+ *                           in to the constructor.
+ */
+
+exports._init = function (options) {
+
+  options = options || {}
+
+  this.$el = null
+  this.$parent = options._parent
+  this.$root = options._root || this
+  this.$children = []
+  this.$ = {}           // child vm references
+  this.$$ = {}          // element references
+  this._watchers = []   // all watchers as an array
+  this._directives = [] // all directives
+  this._childCtors = {} // inherit:true constructors
+
+  // a flag to avoid this being observed
+  this._isVue = true
+
+  // events bookkeeping
+  this._events = {}            // registered callbacks
+  this._eventsCount = {}       // for $broadcast optimization
+  this._eventCancelled = false // for event cancellation
+
+  // fragment instance properties
+  this._isFragment = false
+  this._fragmentStart =    // @type {CommentNode}
+  this._fragmentEnd = null // @type {CommentNode}
+
+  // lifecycle state
+  this._isCompiled =
+  this._isDestroyed =
+  this._isReady =
+  this._isAttached =
+  this._isBeingDestroyed = false
+  this._unlinkFn = null
+
+  // context: the scope in which the component was used,
+  // and the scope in which props and contents of this
+  // instance should be compiled in.
+  this._context =
+    options._context ||
+    options._parent
+
+  // push self into parent / transclusion host
+  if (this.$parent) {
+    this.$parent.$children.push(this)
+  }
+
+  // props used in v-repeat diffing
+  this._reused = false
+  this._staggerOp = null
+
+  // merge options.
+  options = this.$options = mergeOptions(
+    this.constructor.options,
+    options,
+    this
+  )
+
+  // initialize data as empty object.
+  // it will be filled up in _initScope().
+  this._data = {}
+
+  // initialize data observation and scope inheritance.
+  this._initScope()
+
+  // setup event system and option events.
+  this._initEvents()
+
+  // call created hook
+  this._callHook('created')
+
+  // if `el` option is passed, start compilation.
+  if (options.el) {
+    this.$mount(options.el)
+  }
+}

data/vendor/assets/bower_components/vue/src/instance/misc.js

@@ -0,0 +1,93 @@
+var _ = require('../util')
+
+/**
+ * Apply a list of filter (descriptors) to a value.
+ * Using plain for loops here because this will be called in
+ * the getter of any watcher with filters so it is very
+ * performance sensitive.
+ *
+ * @param {*} value
+ * @param {*} [oldValue]
+ * @param {Array} filters
+ * @param {Boolean} write
+ * @return {*}
+ */
+
+exports._applyFilters = function (value, oldValue, filters, write) {
+  var filter, fn, args, arg, offset, i, l, j, k
+  for (i = 0, l = filters.length; i < l; i++) {
+    filter = filters[i]
+    fn = _.resolveAsset(this.$options, 'filters', filter.name)
+    if (process.env.NODE_ENV !== 'production') {
+      _.assertAsset(fn, 'filter', filter.name)
+    }
+    if (!fn) continue
+    fn = write ? fn.write : (fn.read || fn)
+    if (typeof fn !== 'function') continue
+    args = write ? [value, oldValue] : [value]
+    offset = write ? 2 : 1
+    if (filter.args) {
+      for (j = 0, k = filter.args.length; j < k; j++) {
+        arg = filter.args[j]
+        args[j + offset] = arg.dynamic
+          ? this.$get(arg.value)
+          : arg.value
+      }
+    }
+    value = fn.apply(this, args)
+  }
+  return value
+}
+
+/**
+ * Resolve a component, depending on whether the component
+ * is defined normally or using an async factory function.
+ * Resolves synchronously if already resolved, otherwise
+ * resolves asynchronously and caches the resolved
+ * constructor on the factory.
+ *
+ * @param {String} id
+ * @param {Function} cb
+ */
+
+exports._resolveComponent = function (id, cb) {
+  var factory = _.resolveAsset(this.$options, 'components', id)
+  if (process.env.NODE_ENV !== 'production') {
+    _.assertAsset(factory, 'component', id)
+  }
+  if (!factory) {
+    return
+  }
+  // async component factory
+  if (!factory.options) {
+    if (factory.resolved) {
+      // cached
+      cb(factory.resolved)
+    } else if (factory.requested) {
+      // pool callbacks
+      factory.pendingCallbacks.push(cb)
+    } else {
+      factory.requested = true
+      var cbs = factory.pendingCallbacks = [cb]
+      factory(function resolve (res) {
+        if (_.isPlainObject(res)) {
+          res = _.Vue.extend(res)
+        }
+        // cache resolved
+        factory.resolved = res
+        // invoke callbacks
+        for (var i = 0, l = cbs.length; i < l; i++) {
+          cbs[i](res)
+        }
+      }, function reject (reason) {
+        process.env.NODE_ENV !== 'production' && _.warn(
+          'Failed to resolve async component: ' + id + '. ' +
+          (reason ? '\nReason: ' + reason : '')
+        )
+      })
+    }
+  } else {
+    // normal component
+    cb(factory)
+  }
+}

data/vendor/assets/bower_components/vue/src/instance/scope.js

@@ -0,0 +1,282 @@
+var _ = require('../util')
+var compiler = require('../compiler')
+var Observer = require('../observer')
+var Dep = require('../observer/dep')
+var Watcher = require('../watcher')
+
+/**
+ * Setup the scope of an instance, which contains:
+ * - observed data
+ * - computed properties
+ * - user methods
+ * - meta properties
+ */
+
+exports._initScope = function () {
+  this._initProps()
+  this._initMeta()
+  this._initMethods()
+  this._initData()
+  this._initComputed()
+}
+
+/**
+ * Initialize props.
+ */
+
+exports._initProps = function () {
+  var options = this.$options
+  var el = options.el
+  var props = options.props
+  if (props && !el) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Props will not be compiled if no `el` option is ' +
+      'provided at instantiation.'
+    )
+  }
+  // make sure to convert string selectors into element now
+  el = options.el = _.query(el)
+  this._propsUnlinkFn = el && el.nodeType === 1 && props
+    ? compiler.compileAndLinkProps(
+        this, el, props
+      )
+    : null
+}
+
+/**
+ * Initialize the data.
+ */
+
+exports._initData = function () {
+  var propsData = this._data
+  var optionsDataFn = this.$options.data
+  var optionsData = optionsDataFn && optionsDataFn()
+  if (optionsData) {
+    this._data = optionsData
+    for (var prop in propsData) {
+      if (
+        this._props[prop].raw !== null ||
+        !optionsData.hasOwnProperty(prop)
+      ) {
+        optionsData.$set(prop, propsData[prop])
+      }
+    }
+  }
+  var data = this._data
+  // proxy data on instance
+  var keys = Object.keys(data)
+  var i, key
+  i = keys.length
+  while (i--) {
+    key = keys[i]
+    if (!_.isReserved(key)) {
+      this._proxy(key)
+    }
+  }
+  // observe data
+  Observer.create(data, this)
+}
+
+/**
+ * Swap the isntance's $data. Called in $data's setter.
+ *
+ * @param {Object} newData
+ */
+
+exports._setData = function (newData) {
+  newData = newData || {}
+  var oldData = this._data
+  this._data = newData
+  var keys, key, i
+  // copy props.
+  // this should only happen during a v-repeat of component
+  // that also happens to have compiled props.
+  var props = this.$options.props
+  if (props) {
+    i = props.length
+    while (i--) {
+      key = props[i].name
+      if (key !== '$data' && !newData.hasOwnProperty(key)) {
+        newData.$set(key, oldData[key])
+      }
+    }
+  }
+  // unproxy keys not present in new data
+  keys = Object.keys(oldData)
+  i = keys.length
+  while (i--) {
+    key = keys[i]
+    if (!_.isReserved(key) && !(key in newData)) {
+      this._unproxy(key)
+    }
+  }
+  // proxy keys not already proxied,
+  // and trigger change for changed values
+  keys = Object.keys(newData)
+  i = keys.length
+  while (i--) {
+    key = keys[i]
+    if (!this.hasOwnProperty(key) && !_.isReserved(key)) {
+      // new property
+      this._proxy(key)
+    }
+  }
+  oldData.__ob__.removeVm(this)
+  Observer.create(newData, this)
+  this._digest()
+}
+
+/**
+ * Proxy a property, so that
+ * vm.prop === vm._data.prop
+ *
+ * @param {String} key
+ */
+
+exports._proxy = function (key) {
+  // need to store ref to self here
+  // because these getter/setters might
+  // be called by child instances!
+  var self = this
+  Object.defineProperty(self, key, {
+    configurable: true,
+    enumerable: true,
+    get: function proxyGetter () {
+      return self._data[key]
+    },
+    set: function proxySetter (val) {
+      self._data[key] = val
+    }
+  })
+}
+
+/**
+ * Unproxy a property.
+ *
+ * @param {String} key
+ */
+
+exports._unproxy = function (key) {
+  delete this[key]
+}
+
+/**
+ * Force update on every watcher in scope.
+ */
+
+exports._digest = function () {
+  var i = this._watchers.length
+  while (i--) {
+    this._watchers[i].update(true) // shallow updates
+  }
+  var children = this.$children
+  i = children.length
+  while (i--) {
+    var child = children[i]
+    if (child.$options.inherit) {
+      child._digest()
+    }
+  }
+}
+
+/**
+ * Setup computed properties. They are essentially
+ * special getter/setters
+ */
+
+function noop () {}
+exports._initComputed = function () {
+  var computed = this.$options.computed
+  if (computed) {
+    for (var key in computed) {
+      var userDef = computed[key]
+      var def = {
+        enumerable: true,
+        configurable: true
+      }
+      if (typeof userDef === 'function') {
+        def.get = makeComputedGetter(userDef, this)
+        def.set = noop
+      } else {
+        def.get = userDef.get
+          ? userDef.cache !== false
+            ? makeComputedGetter(userDef.get, this)
+            : _.bind(userDef.get, this)
+          : noop
+        def.set = userDef.set
+          ? _.bind(userDef.set, this)
+          : noop
+      }
+      Object.defineProperty(this, key, def)
+    }
+  }
+}
+
+function makeComputedGetter (getter, owner) {
+  var watcher = new Watcher(owner, getter, null, {
+    lazy: true
+  })
+  return function computedGetter () {
+    if (watcher.dirty) {
+      watcher.evaluate()
+    }
+    if (Dep.target) {
+      watcher.depend()
+    }
+    return watcher.value
+  }
+}
+
+/**
+ * Setup instance methods. Methods must be bound to the
+ * instance since they might be called by children
+ * inheriting them.
+ */
+
+exports._initMethods = function () {
+  var methods = this.$options.methods
+  if (methods) {
+    for (var key in methods) {
+      this[key] = _.bind(methods[key], this)
+    }
+  }
+}
+
+/**
+ * Initialize meta information like $index, $key & $value.
+ */
+
+exports._initMeta = function () {
+  var metas = this.$options._meta
+  if (metas) {
+    for (var key in metas) {
+      this._defineMeta(key, metas[key])
+    }
+  }
+}
+
+/**
+ * Define a meta property, e.g $index, $key, $value
+ * which only exists on the vm instance but not in $data.
+ *
+ * @param {String} key
+ * @param {*} value
+ */
+
+exports._defineMeta = function (key, value) {
+  var dep = new Dep()
+  Object.defineProperty(this, key, {
+    get: function metaGetter () {
+      if (Dep.target) {
+        dep.depend()
+      }
+      return value
+    },
+    set: function metaSetter (val) {
+      if (val !== value) {
+        value = val
+        dep.notify()
+      }
+    }
+  })
+}