plate-lang 0.1.0

data/skeleton/vendor/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 && 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
+          ? makeComputedGetter(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, {
+    enumerable: true,
+    configurable: true,
+    get: function metaGetter () {
+      if (Dep.target) {
+        dep.depend()
+      }
+      return value
+    },
+    set: function metaSetter (val) {
+      if (val !== value) {
+        value = val
+        dep.notify()
+      }
+    }
+  })
+}

data/skeleton/vendor/vue/src/observer/array.js

@@ -0,0 +1,92 @@
+var _ = require('../util')
+var arrayProto = Array.prototype
+var arrayMethods = Object.create(arrayProto)
+
+/**
+ * Intercept mutating methods and emit events
+ */
+
+;[
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'splice',
+  'sort',
+  'reverse'
+]
+.forEach(function (method) {
+  // cache original method
+  var original = arrayProto[method]
+  _.define(arrayMethods, method, function mutator () {
+    // avoid leaking arguments:
+    // http://jsperf.com/closure-with-arguments
+    var i = arguments.length
+    var args = new Array(i)
+    while (i--) {
+      args[i] = arguments[i]
+    }
+    var result = original.apply(this, args)
+    var ob = this.__ob__
+    var inserted
+    switch (method) {
+      case 'push':
+        inserted = args
+        break
+      case 'unshift':
+        inserted = args
+        break
+      case 'splice':
+        inserted = args.slice(2)
+        break
+    }
+    if (inserted) ob.observeArray(inserted)
+    // notify change
+    ob.dep.notify()
+    return result
+  })
+})
+
+/**
+ * Swap the element at the given index with a new value
+ * and emits corresponding event.
+ *
+ * @param {Number} index
+ * @param {*} val
+ * @return {*} - replaced element
+ */
+
+_.define(
+  arrayProto,
+  '$set',
+  function $set (index, val) {
+    if (index >= this.length) {
+      this.length = index + 1
+    }
+    return this.splice(index, 1, val)[0]
+  }
+)
+
+/**
+ * Convenience method to remove the element at given index.
+ *
+ * @param {Number} index
+ * @param {*} val
+ */
+
+_.define(
+  arrayProto,
+  '$remove',
+  function $remove (index) {
+    /* istanbul ignore if */
+    if (!this.length) return
+    if (typeof index !== 'number') {
+      index = _.indexOf(this, index)
+    }
+    if (index > -1) {
+      return this.splice(index, 1)
+    }
+  }
+)
+
+module.exports = arrayMethods

data/skeleton/vendor/vue/src/observer/dep.js

@@ -0,0 +1,61 @@
+var _ = require('../util')
+
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ *
+ * @constructor
+ */
+
+function Dep () {
+  this.subs = []
+}
+
+// the current target watcher being evaluated.
+// this is globally unique because there could be only one
+// watcher being evaluated at any time.
+Dep.target = null
+
+var p = Dep.prototype
+
+/**
+ * Add a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+p.addSub = function (sub) {
+  this.subs.push(sub)
+}
+
+/**
+ * Remove a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+p.removeSub = function (sub) {
+  this.subs.$remove(sub)
+}
+
+/**
+ * Add self as a dependency to the target watcher.
+ */
+
+p.depend = function () {
+  Dep.target.addDep(this)
+}
+
+/**
+ * Notify all subscribers of a new value.
+ */
+
+p.notify = function () {
+  // stablize the subscriber list first
+  var subs = _.toArray(this.subs)
+  for (var i = 0, l = subs.length; i < l; i++) {
+    subs[i].update()
+  }
+}
+
+module.exports = Dep

data/skeleton/vendor/vue/src/observer/index.js

@@ -0,0 +1,212 @@
+var _ = require('../util')
+var config = require('../config')
+var Dep = require('./dep')
+var arrayMethods = require('./array')
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+require('./object')
+
+/**
+ * Observer class that are attached to each observed
+ * object. Once attached, the observer converts target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatches updates.
+ *
+ * @param {Array|Object} value
+ * @constructor
+ */
+
+function Observer (value) {
+  this.value = value
+  this.dep = new Dep()
+  _.define(value, '__ob__', this)
+  if (_.isArray(value)) {
+    var augment = config.proto && _.hasProto
+      ? protoAugment
+      : copyAugment
+    augment(value, arrayMethods, arrayKeys)
+    this.observeArray(value)
+  } else {
+    this.walk(value)
+  }
+}
+
+// Static methods
+
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ *
+ * @param {*} value
+ * @param {Vue} [vm]
+ * @return {Observer|undefined}
+ * @static
+ */
+
+Observer.create = function (value, vm) {
+  var ob
+  if (
+    value &&
+    value.hasOwnProperty('__ob__') &&
+    value.__ob__ instanceof Observer
+  ) {
+    ob = value.__ob__
+  } else if (
+    _.isObject(value) &&
+    !Object.isFrozen(value) &&
+    !value._isVue
+  ) {
+    ob = new Observer(value)
+  }
+  if (ob && vm) {
+    ob.addVm(vm)
+  }
+  return ob
+}
+
+// Instance methods
+
+var p = Observer.prototype
+
+/**
+ * Walk through each property and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object. Properties prefixed with `$` or `_`
+ * and accessor properties are ignored.
+ *
+ * @param {Object} obj
+ */
+
+p.walk = function (obj) {
+  var keys = Object.keys(obj)
+  var i = keys.length
+  var key, prefix
+  while (i--) {
+    key = keys[i]
+    prefix = key.charCodeAt(0)
+    if (prefix !== 0x24 && prefix !== 0x5F) { // skip $ or _
+      this.convert(key, obj[key])
+    }
+  }
+}
+
+/**
+ * Try to carete an observer for a child value,
+ * and if value is array, link dep to the array.
+ *
+ * @param {*} val
+ * @return {Dep|undefined}
+ */
+
+p.observe = function (val) {
+  return Observer.create(val)
+}
+
+/**
+ * Observe a list of Array items.
+ *
+ * @param {Array} items
+ */
+
+p.observeArray = function (items) {
+  var i = items.length
+  while (i--) {
+    this.observe(items[i])
+  }
+}
+
+/**
+ * Convert a property into getter/setter so we can emit
+ * the events when the property is accessed/changed.
+ *
+ * @param {String} key
+ * @param {*} val
+ */
+
+p.convert = function (key, val) {
+  var ob = this
+  var childOb = ob.observe(val)
+  var dep = new Dep()
+  Object.defineProperty(ob.value, key, {
+    enumerable: true,
+    configurable: true,
+    get: function () {
+      if (Dep.target) {
+        dep.depend()
+        if (childOb) {
+          childOb.dep.depend()
+        }
+        if (_.isArray(val)) {
+          for (var e, i = 0, l = val.length; i < l; i++) {
+            e = val[i]
+            e && e.__ob__ && e.__ob__.dep.depend()
+          }
+        }
+      }
+      return val
+    },
+    set: function (newVal) {
+      if (newVal === val) return
+      val = newVal
+      childOb = ob.observe(newVal)
+      dep.notify()
+    }
+  })
+}
+
+/**
+ * Add an owner vm, so that when $add/$delete mutations
+ * happen we can notify owner vms to proxy the keys and
+ * digest the watchers. This is only called when the object
+ * is observed as an instance's root $data.
+ *
+ * @param {Vue} vm
+ */
+
+p.addVm = function (vm) {
+  (this.vms || (this.vms = [])).push(vm)
+}
+
+/**
+ * Remove an owner vm. This is called when the object is
+ * swapped out as an instance's $data object.
+ *
+ * @param {Vue} vm
+ */
+
+p.removeVm = function (vm) {
+  this.vms.$remove(vm)
+}
+
+// helpers
+
+/**
+ * Augment an target Object or Array by intercepting
+ * the prototype chain using __proto__
+ *
+ * @param {Object|Array} target
+ * @param {Object} proto
+ */
+
+function protoAugment (target, src) {
+  target.__proto__ = src
+}
+
+/**
+ * Augment an target Object or Array by defining
+ * hidden properties.
+ *
+ * @param {Object|Array} target
+ * @param {Object} proto
+ */
+
+function copyAugment (target, src, keys) {
+  var i = keys.length
+  var key
+  while (i--) {
+    key = keys[i]
+    _.define(target, key, src[key])
+  }
+}
+
+module.exports = Observer

data/skeleton/vendor/vue/src/observer/object.js

@@ -0,0 +1,82 @@
+var _ = require('../util')
+var objProto = Object.prototype
+
+/**
+ * Add a new property to an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @param {*} val
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$add',
+  function $add (key, val) {
+    if (this.hasOwnProperty(key)) return
+    var ob = this.__ob__
+    if (!ob || _.isReserved(key)) {
+      this[key] = val
+      return
+    }
+    ob.convert(key, val)
+    ob.dep.notify()
+    if (ob.vms) {
+      var i = ob.vms.length
+      while (i--) {
+        var vm = ob.vms[i]
+        vm._proxy(key)
+        vm._digest()
+      }
+    }
+  }
+)
+
+/**
+ * Set a property on an observed object, calling add to
+ * ensure the property is observed.
+ *
+ * @param {String} key
+ * @param {*} val
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$set',
+  function $set (key, val) {
+    this.$add(key, val)
+    this[key] = val
+  }
+)
+
+/**
+ * Deletes a property from an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$delete',
+  function $delete (key) {
+    if (!this.hasOwnProperty(key)) return
+    delete this[key]
+    var ob = this.__ob__
+    if (!ob || _.isReserved(key)) {
+      return
+    }
+    ob.dep.notify()
+    if (ob.vms) {
+      var i = ob.vms.length
+      while (i--) {
+        var vm = ob.vms[i]
+        vm._unproxy(key)
+        vm._digest()
+      }
+    }
+  }
+)