plate-lang 0.1.0

data/skeleton/vendor/vue/src/instance/compile.js

@@ -0,0 +1,196 @@
+var _ = require('../util')
+var Directive = require('../directive')
+var compiler = require('../compiler')
+
+/**
+ * Transclude, compile and link element.
+ *
+ * If a pre-compiled linker is available, that means the
+ * passed in element will be pre-transcluded and compiled
+ * as well - all we need to do is to call the linker.
+ *
+ * Otherwise we need to call transclude/compile/link here.
+ *
+ * @param {Element} el
+ * @return {Element}
+ */
+
+exports._compile = function (el) {
+  var options = this.$options
+  var host = this._host
+  if (options._linkFn) {
+    // pre-transcluded with linker, just use it
+    this._initElement(el)
+    this._unlinkFn = options._linkFn(this, el, host)
+  } else {
+    // transclude and init element
+    // transclude can potentially replace original
+    // so we need to keep reference; this step also injects
+    // the template and caches the original attributes
+    // on the container node and replacer node.
+    var original = el
+    el = compiler.transclude(el, options)
+    this._initElement(el)
+
+    // root is always compiled per-instance, because
+    // container attrs and props can be different every time.
+    var rootUnlinkFn =
+      compiler.compileAndLinkRoot(this, el, options)
+
+    // compile and link the rest
+    var linker
+    var ctor = this.constructor
+    // component compilation can be cached
+    // as long as it's not using inline-template
+    if (options._linkerCachable) {
+      linker = ctor.linker
+      if (!linker) {
+        linker = ctor.linker = compiler.compile(el, options)
+      }
+    }
+    var contentUnlinkFn = linker
+      ? linker(this, el)
+      : compiler.compile(el, options)(this, el, host)
+
+    this._unlinkFn = function () {
+      rootUnlinkFn()
+      // passing destroying: true to avoid searching and
+      // splicing the directives
+      contentUnlinkFn(true)
+    }
+
+    // finally replace original
+    if (options.replace) {
+      _.replace(original, el)
+    }
+  }
+  return el
+}
+
+/**
+ * Initialize instance element. Called in the public
+ * $mount() method.
+ *
+ * @param {Element} el
+ */
+
+exports._initElement = function (el) {
+  if (el instanceof DocumentFragment) {
+    this._isFragment = true
+    this.$el = this._fragmentStart = el.firstChild
+    this._fragmentEnd = el.lastChild
+    // set persisted text anchors to empty
+    if (this._fragmentStart.nodeType === 3) {
+      this._fragmentStart.data = this._fragmentEnd.data = ''
+    }
+    this._blockFragment = el
+  } else {
+    this.$el = el
+  }
+  this.$el.__vue__ = this
+  this._callHook('beforeCompile')
+}
+
+/**
+ * Create and bind a directive to an element.
+ *
+ * @param {String} name - directive name
+ * @param {Node} node   - target node
+ * @param {Object} desc - parsed directive descriptor
+ * @param {Object} def  - directive definition object
+ * @param {Vue|undefined} host - transclusion host component
+ */
+
+exports._bindDir = function (name, node, desc, def, host) {
+  this._directives.push(
+    new Directive(name, node, this, desc, def, host)
+  )
+}
+
+/**
+ * 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
+ */
+
+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) {
+    parent.$children.$remove(this)
+  }
+  // destroy all children.
+  i = this.$children.length
+  while (i--) {
+    this.$children[i].$destroy()
+  }
+  // teardown props
+  if (this._propsUnlinkFn) {
+    this._propsUnlinkFn()
+  }
+  // teardown all directives. this also tearsdown all
+  // directive-owned watchers.
+  if (this._unlinkFn) {
+    this._unlinkFn()
+  }
+  i = this._watchers.length
+  while (i--) {
+    this._watchers[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
+  // frozen object may not have observer.
+  if (this._data.__ob__) {
+    this._data.__ob__.removeVm(this)
+  }
+  // Clean up references to private properties and other
+  // instances. preserve reference to _data so that proxy
+  // accessors still work. The only potential side effect
+  // here is that mutating the instance after it's destroyed
+  // may affect the state of other components that are still
+  // observing the same object, but that seems to be a
+  // reasonable responsibility for the user rather than
+  // always throwing an error on them.
+  this.$el =
+  this.$parent =
+  this.$root =
+  this.$children =
+  this._watchers =
+  this._directives = null
+  // call the last hook...
+  this._isDestroyed = true
+  this._callHook('destroyed')
+  // turn off all instance listeners.
+  this.$off()
+}

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

@@ -0,0 +1,139 @@
+var _ = require('../util')
+var inDoc = _.inDoc
+
+/**
+ * Setup the instance's option events & watchers.
+ * If the value is a string, we pull it from the
+ * instance's methods by name.
+ */
+
+exports._initEvents = function () {
+  var options = this.$options
+  registerCallbacks(this, '$on', options.events)
+  registerCallbacks(this, '$watch', options.watch)
+}
+
+/**
+ * Register callbacks for option events and watchers.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {Object} hash
+ */
+
+function registerCallbacks (vm, action, hash) {
+  if (!hash) return
+  var handlers, key, i, j
+  for (key in hash) {
+    handlers = hash[key]
+    if (_.isArray(handlers)) {
+      for (i = 0, j = handlers.length; i < j; i++) {
+        register(vm, action, key, handlers[i])
+      }
+    } else {
+      register(vm, action, key, handlers)
+    }
+  }
+}
+
+/**
+ * Helper to register an event/watch callback.
+ *
+ * @param {Vue} vm
+ * @param {String} action
+ * @param {String} key
+ * @param {Function|String|Object} handler
+ * @param {Object} [options]
+ */
+
+function register (vm, action, key, handler, options) {
+  var type = typeof handler
+  if (type === 'function') {
+    vm[action](key, handler, options)
+  } else if (type === 'string') {
+    var methods = vm.$options.methods
+    var method = methods && methods[handler]
+    if (method) {
+      vm[action](key, method, options)
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Unknown method: "' + handler + '" when ' +
+        'registering callback for ' + action +
+        ': "' + key + '".'
+      )
+    }
+  } else if (handler && type === 'object') {
+    register(vm, action, key, handler.handler, handler)
+  }
+}
+
+/**
+ * Setup recursive attached/detached calls
+ */
+
+exports._initDOMHooks = function () {
+  this.$on('hook:attached', onAttached)
+  this.$on('hook:detached', onDetached)
+}
+
+/**
+ * Callback to recursively call attached hook on children
+ */
+
+function onAttached () {
+  if (!this._isAttached) {
+    this._isAttached = true
+    this.$children.forEach(callAttach)
+  }
+}
+
+/**
+ * Iterator to call attached hook
+ *
+ * @param {Vue} child
+ */
+
+function callAttach (child) {
+  if (!child._isAttached && inDoc(child.$el)) {
+    child._callHook('attached')
+  }
+}
+
+/**
+ * Callback to recursively call detached hook on children
+ */
+
+function onDetached () {
+  if (this._isAttached) {
+    this._isAttached = false
+    this.$children.forEach(callDetach)
+  }
+}
+
+/**
+ * Iterator to call detached hook
+ *
+ * @param {Vue} child
+ */
+
+function callDetach (child) {
+  if (child._isAttached && !inDoc(child.$el)) {
+    child._callHook('detached')
+  }
+}
+
+/**
+ * Trigger all handlers for a hook
+ *
+ * @param {String} hook
+ */
+
+exports._callHook = function (hook) {
+  var handlers = this.$options[hook]
+  if (handlers) {
+    for (var i = 0, j = handlers.length; i < j; i++) {
+      handlers[i].call(this)
+    }
+  }
+  this.$emit('hook:' + hook)
+}

data/skeleton/vendor/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/skeleton/vendor/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)
+  }
+}