plate-lang 0.1.0

data/skeleton/vendor/vue/src/api/dom.js

@@ -0,0 +1,226 @@
+var _ = require('../util')
+var transition = require('../transition')
+
+/**
+ * Convenience on-instance nextTick. The callback is
+ * auto-bound to the instance, and this avoids component
+ * modules having to rely on the global Vue.
+ *
+ * @param {Function} fn
+ */
+
+exports.$nextTick = function (fn) {
+  _.nextTick(fn, this)
+}
+
+/**
+ * Append instance to target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$appendTo = function (target, cb, withTransition) {
+  return insert(
+    this, target, cb, withTransition,
+    append, transition.append
+  )
+}
+
+/**
+ * Prepend instance to target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$prependTo = function (target, cb, withTransition) {
+  target = query(target)
+  if (target.hasChildNodes()) {
+    this.$before(target.firstChild, cb, withTransition)
+  } else {
+    this.$appendTo(target, cb, withTransition)
+  }
+  return this
+}
+
+/**
+ * Insert instance before target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$before = function (target, cb, withTransition) {
+  return insert(
+    this, target, cb, withTransition,
+    before, transition.before
+  )
+}
+
+/**
+ * Insert instance after target
+ *
+ * @param {Node} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$after = function (target, cb, withTransition) {
+  target = query(target)
+  if (target.nextSibling) {
+    this.$before(target.nextSibling, cb, withTransition)
+  } else {
+    this.$appendTo(target.parentNode, cb, withTransition)
+  }
+  return this
+}
+
+/**
+ * Remove instance from DOM
+ *
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition] - defaults to true
+ */
+
+exports.$remove = function (cb, withTransition) {
+  if (!this.$el.parentNode) {
+    return cb && cb()
+  }
+  var inDoc = this._isAttached && _.inDoc(this.$el)
+  // if we are not in document, no need to check
+  // for transitions
+  if (!inDoc) withTransition = false
+  var op
+  var self = this
+  var realCb = function () {
+    if (inDoc) self._callHook('detached')
+    if (cb) cb()
+  }
+  if (
+    this._isFragment &&
+    !this._blockFragment.hasChildNodes()
+  ) {
+    op = withTransition === false
+      ? append
+      : transition.removeThenAppend
+    blockOp(this, this._blockFragment, op, realCb)
+  } else {
+    op = withTransition === false
+      ? remove
+      : transition.remove
+    op(this.$el, this, realCb)
+  }
+  return this
+}
+
+/**
+ * Shared DOM insertion function.
+ *
+ * @param {Vue} vm
+ * @param {Element} target
+ * @param {Function} [cb]
+ * @param {Boolean} [withTransition]
+ * @param {Function} op1 - op for non-transition insert
+ * @param {Function} op2 - op for transition insert
+ * @return vm
+ */
+
+function insert (vm, target, cb, withTransition, op1, op2) {
+  target = query(target)
+  var targetIsDetached = !_.inDoc(target)
+  var op = withTransition === false || targetIsDetached
+    ? op1
+    : op2
+  var shouldCallHook =
+    !targetIsDetached &&
+    !vm._isAttached &&
+    !_.inDoc(vm.$el)
+  if (vm._isFragment) {
+    blockOp(vm, target, op, cb)
+  } else {
+    op(vm.$el, target, vm, cb)
+  }
+  if (shouldCallHook) {
+    vm._callHook('attached')
+  }
+  return vm
+}
+
+/**
+ * Execute a transition operation on a fragment instance,
+ * iterating through all its block nodes.
+ *
+ * @param {Vue} vm
+ * @param {Node} target
+ * @param {Function} op
+ * @param {Function} cb
+ */
+
+function blockOp (vm, target, op, cb) {
+  var current = vm._fragmentStart
+  var end = vm._fragmentEnd
+  var next
+  while (next !== end) {
+    next = current.nextSibling
+    op(current, target, vm)
+    current = next
+  }
+  op(end, target, vm, cb)
+}
+
+/**
+ * Check for selectors
+ *
+ * @param {String|Element} el
+ */
+
+function query (el) {
+  return typeof el === 'string'
+    ? document.querySelector(el)
+    : el
+}
+
+/**
+ * Append operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Node} target
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function append (el, target, vm, cb) {
+  target.appendChild(el)
+  if (cb) cb()
+}
+
+/**
+ * InsertBefore operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Node} target
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function before (el, target, vm, cb) {
+  _.before(el, target)
+  if (cb) cb()
+}
+
+/**
+ * Remove operation that takes a callback.
+ *
+ * @param {Node} el
+ * @param {Vue} vm - unused
+ * @param {Function} [cb]
+ */
+
+function remove (el, vm, cb) {
+  _.remove(el)
+  if (cb) cb()
+}

data/skeleton/vendor/vue/src/api/events.js

@@ -0,0 +1,174 @@
+var _ = require('../util')
+
+/**
+ * Listen on the given `event` with `fn`.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ */
+
+exports.$on = function (event, fn) {
+  (this._events[event] || (this._events[event] = []))
+    .push(fn)
+  modifyListenerCount(this, event, 1)
+  return this
+}
+
+/**
+ * Adds an `event` listener that will be invoked a single
+ * time then automatically removed.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ */
+
+exports.$once = function (event, fn) {
+  var self = this
+  function on () {
+    self.$off(event, on)
+    fn.apply(this, arguments)
+  }
+  on.fn = fn
+  this.$on(event, on)
+  return this
+}
+
+/**
+ * Remove the given callback for `event` or all
+ * registered callbacks.
+ *
+ * @param {String} event
+ * @param {Function} fn
+ */
+
+exports.$off = function (event, fn) {
+  var cbs
+  // all
+  if (!arguments.length) {
+    if (this.$parent) {
+      for (event in this._events) {
+        cbs = this._events[event]
+        if (cbs) {
+          modifyListenerCount(this, event, -cbs.length)
+        }
+      }
+    }
+    this._events = {}
+    return this
+  }
+  // specific event
+  cbs = this._events[event]
+  if (!cbs) {
+    return this
+  }
+  if (arguments.length === 1) {
+    modifyListenerCount(this, event, -cbs.length)
+    this._events[event] = null
+    return this
+  }
+  // specific handler
+  var cb
+  var i = cbs.length
+  while (i--) {
+    cb = cbs[i]
+    if (cb === fn || cb.fn === fn) {
+      modifyListenerCount(this, event, -1)
+      cbs.splice(i, 1)
+      break
+    }
+  }
+  return this
+}
+
+/**
+ * Trigger an event on self.
+ *
+ * @param {String} event
+ */
+
+exports.$emit = function (event) {
+  this._eventCancelled = false
+  var cbs = this._events[event]
+  if (cbs) {
+    // avoid leaking arguments:
+    // http://jsperf.com/closure-with-arguments
+    var i = arguments.length - 1
+    var args = new Array(i)
+    while (i--) {
+      args[i] = arguments[i + 1]
+    }
+    i = 0
+    cbs = cbs.length > 1
+      ? _.toArray(cbs)
+      : cbs
+    for (var l = cbs.length; i < l; i++) {
+      if (cbs[i].apply(this, args) === false) {
+        this._eventCancelled = true
+      }
+    }
+  }
+  return this
+}
+
+/**
+ * Recursively broadcast an event to all children instances.
+ *
+ * @param {String} event
+ * @param {...*} additional arguments
+ */
+
+exports.$broadcast = function (event) {
+  // if no child has registered for this event,
+  // then there's no need to broadcast.
+  if (!this._eventsCount[event]) return
+  var children = this.$children
+  for (var i = 0, l = children.length; i < l; i++) {
+    var child = children[i]
+    child.$emit.apply(child, arguments)
+    if (!child._eventCancelled) {
+      child.$broadcast.apply(child, arguments)
+    }
+  }
+  return this
+}
+
+/**
+ * Recursively propagate an event up the parent chain.
+ *
+ * @param {String} event
+ * @param {...*} additional arguments
+ */
+
+exports.$dispatch = function () {
+  var parent = this.$parent
+  while (parent) {
+    parent.$emit.apply(parent, arguments)
+    parent = parent._eventCancelled
+      ? null
+      : parent.$parent
+  }
+  return this
+}
+
+/**
+ * Modify the listener counts on all parents.
+ * This bookkeeping allows $broadcast to return early when
+ * no child has listened to a certain event.
+ *
+ * @param {Vue} vm
+ * @param {String} event
+ * @param {Number} count
+ */
+
+var hookRE = /^hook:/
+function modifyListenerCount (vm, event, count) {
+  var parent = vm.$parent
+  // hooks do not get broadcasted so no need
+  // to do bookkeeping for them
+  if (!parent || !count || hookRE.test(event)) return
+  while (parent) {
+    parent._eventsCount[event] =
+      (parent._eventsCount[event] || 0) + count
+    parent = parent.$parent
+  }
+}

data/skeleton/vendor/vue/src/api/global.js

@@ -0,0 +1,119 @@
+var _ = require('../util')
+var config = require('../config')
+
+/**
+ * Expose useful internals
+ */
+
+exports.util = _
+exports.config = config
+exports.nextTick = _.nextTick
+exports.compiler = require('../compiler')
+
+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 inheritance
+ *
+ * @param {Object} extendOptions
+ */
+
+exports.extend = function (extendOptions) {
+  extendOptions = extendOptions || {}
+  var Super = this
+  var Sub = createClass(
+    extendOptions.name ||
+    Super.options.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.
+  config._assetTypes.forEach(function (type) {
+    Sub[type] = Super[type]
+  })
+  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 ' + _.classify(name) +
+    ' (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
+}
+
+/**
+ * Create asset registration methods with the following
+ * signature:
+ *
+ * @param {String} id
+ * @param {*} definition
+ */
+
+config._assetTypes.forEach(function (type) {
+  exports[type] = function (id, definition) {
+    if (!definition) {
+      return this.options[type + 's'][id]
+    } else {
+      if (
+        type === 'component' &&
+        _.isPlainObject(definition)
+      ) {
+        definition.name = id
+        definition = _.Vue.extend(definition)
+      }
+      this.options[type + 's'][id] = definition
+    }
+  }
+})

data/skeleton/vendor/vue/src/api/lifecycle.js

@@ -0,0 +1,68 @@
+var _ = require('../util')
+var compiler = require('../compiler')
+
+/**
+ * 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) {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      '$mount() should be called only once.'
+    )
+    return
+  }
+  el = _.query(el)
+  if (!el) {
+    el = document.createElement('div')
+  }
+  this._compile(el)
+  this._isCompiled = true
+  this._callHook('compiled')
+  this._initDOMHooks()
+  if (_.inDoc(this.$el)) {
+    this._callHook('attached')
+    ready.call(this)
+  } else {
+    this.$once('hook:attached', ready)
+  }
+  return this
+}
+
+/**
+ * Mark an instance as ready.
+ */
+
+function ready () {
+  this._isAttached = true
+  this._isReady = true
+  this._callHook('ready')
+}
+
+/**
+ * Teardown the instance, simply delegate to the internal
+ * _destroy.
+ */
+
+exports.$destroy = function (remove, deferCleanup) {
+  this._destroy(remove, deferCleanup)
+}
+
+/**
+ * Partially compile a piece of DOM and return a
+ * decompile function.
+ *
+ * @param {Element|DocumentFragment} el
+ * @param {Vue} [host]
+ * @return {Function}
+ */
+
+exports.$compile = function (el, host) {
+  return compiler.compile(el, this.$options, true, host)(this, el)
+}

data/skeleton/vendor/vue/src/batcher.js

@@ -0,0 +1,98 @@
+var _ = require('./util')
+var config = require('./config')
+
+// we have two separate queues: one for directive updates
+// and one for user watcher registered via $watch().
+// we want to guarantee directive updates to be called
+// before user watchers so that when user watchers are
+// triggered, the DOM would have already been in updated
+// state.
+var queue = []
+var userQueue = []
+var has = {}
+var circular = {}
+var waiting = false
+var internalQueueDepleted = false
+
+/**
+ * Reset the batcher's state.
+ */
+
+function reset () {
+  queue = []
+  userQueue = []
+  has = {}
+  circular = {}
+  waiting = internalQueueDepleted = false
+}
+
+/**
+ * Flush both queues and run the watchers.
+ */
+
+function flush () {
+  run(queue)
+  internalQueueDepleted = true
+  run(userQueue)
+  reset()
+}
+
+/**
+ * Run the watchers in a single queue.
+ *
+ * @param {Array} queue
+ */
+
+function run (queue) {
+  // do not cache length because more watchers might be pushed
+  // as we run existing watchers
+  for (var i = 0; i < queue.length; i++) {
+    var watcher = queue[i]
+    var id = watcher.id
+    has[id] = null
+    watcher.run()
+    // in dev build, check and stop circular updates.
+    if (process.env.NODE_ENV !== 'production' && has[id] != null) {
+      circular[id] = (circular[id] || 0) + 1
+      if (circular[id] > config._maxUpdateCount) {
+        queue.splice(has[id], 1)
+        _.warn(
+          'You may have an infinite update loop for watcher ' +
+          'with expression: ' + watcher.expression
+        )
+      }
+    }
+  }
+}
+
+/**
+ * Push a watcher into the watcher queue.
+ * Jobs with duplicate IDs will be skipped unless it's
+ * pushed when the queue is being flushed.
+ *
+ * @param {Watcher} watcher
+ *   properties:
+ *   - {Number} id
+ *   - {Function} run
+ */
+
+exports.push = function (watcher) {
+  var id = watcher.id
+  if (has[id] == null) {
+    // if an internal watcher is pushed, but the internal
+    // queue is already depleted, we run it immediately.
+    if (internalQueueDepleted && !watcher.user) {
+      watcher.run()
+      return
+    }
+    // push watcher into appropriate queue
+    var q = watcher.user ? userQueue : queue
+    has[id] = q.length
+    q.push(watcher)
+    // queue the flush
+    if (!waiting) {
+      waiting = true
+      _.nextTick(flush)
+    }
+  }
+}