plate-lang 0.1.0

data/skeleton/vendor/vue/src/directives/component.js

@@ -0,0 +1,300 @@
+var _ = require('../util')
+var config = require('../config')
+var templateParser = require('../parsers/template')
+
+module.exports = {
+
+  isLiteral: true,
+
+  /**
+   * Setup. Two possible usages:
+   *
+   * - static:
+   *   v-component="comp"
+   *
+   * - dynamic:
+   *   v-component="{{currentView}}"
+   */
+
+  bind: function () {
+    if (!this.el.__vue__) {
+      // create a ref anchor
+      this.anchor = _.createAnchor('v-component')
+      _.replace(this.el, this.anchor)
+      // check keep-alive options.
+      // If yes, instead of destroying the active vm when
+      // hiding (v-if) or switching (dynamic literal) it,
+      // we simply remove it from the DOM and save it in a
+      // cache object, with its constructor id as the key.
+      this.keepAlive = this._checkParam('keep-alive') != null
+      // wait for event before insertion
+      this.readyEvent = this._checkParam('wait-for')
+      // check ref
+      this.refID = this._checkParam(config.prefix + 'ref')
+      if (this.keepAlive) {
+        this.cache = {}
+      }
+      // check inline-template
+      if (this._checkParam('inline-template') !== null) {
+        // extract inline template as a DocumentFragment
+        this.template = _.extractContent(this.el, true)
+      }
+      // component resolution related state
+      this._pendingCb =
+      this.componentID =
+      this.Component = null
+      // if static, build right now.
+      if (!this._isDynamicLiteral) {
+        this.resolveComponent(this.expression, _.bind(this.initStatic, this))
+      } else {
+        // check dynamic component params
+        this.transMode = this._checkParam('transition-mode')
+      }
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'cannot mount component "' + this.expression + '" ' +
+        'on already mounted element: ' + this.el
+      )
+    }
+  },
+
+  /**
+   * Initialize a static component.
+   */
+
+  initStatic: function () {
+    var child = this.build()
+    var anchor = this.anchor
+    this.setCurrent(child)
+    if (!this.readyEvent) {
+      child.$before(anchor)
+    } else {
+      child.$once(this.readyEvent, function () {
+        child.$before(anchor)
+      })
+    }
+  },
+
+  /**
+   * Public update, called by the watcher in the dynamic
+   * literal scenario, e.g. v-component="{{view}}"
+   */
+
+  update: function (value) {
+    this.setComponent(value)
+  },
+
+  /**
+   * Switch dynamic components. May resolve the component
+   * asynchronously, and perform transition based on
+   * specified transition mode. Accepts a few additional
+   * arguments specifically for vue-router.
+   *
+   * @param {String} value
+   * @param {Object} data
+   * @param {Function} afterBuild
+   * @param {Function} afterTransition
+   */
+
+  setComponent: function (value, data, afterBuild, afterTransition) {
+    this.invalidatePending()
+    if (!value) {
+      // just remove current
+      this.unbuild(true)
+      this.remove(this.childVM, afterTransition)
+      this.unsetCurrent()
+    } else {
+      this.resolveComponent(value, _.bind(function () {
+        this.unbuild(true)
+        var newComponent = this.build(data)
+        /* istanbul ignore if */
+        if (afterBuild) afterBuild(newComponent)
+        var self = this
+        if (this.readyEvent) {
+          newComponent.$once(this.readyEvent, function () {
+            self.transition(newComponent, afterTransition)
+          })
+        } else {
+          this.transition(newComponent, afterTransition)
+        }
+      }, this))
+    }
+  },
+
+  /**
+   * Resolve the component constructor to use when creating
+   * the child vm.
+   */
+
+  resolveComponent: function (id, cb) {
+    var self = this
+    this._pendingCb = _.cancellable(function (component) {
+      self.componentID = id
+      self.Component = component
+      cb()
+    })
+    this.vm._resolveComponent(id, this._pendingCb)
+  },
+
+  /**
+   * When the component changes or unbinds before an async
+   * constructor is resolved, we need to invalidate its
+   * pending callback.
+   */
+
+  invalidatePending: function () {
+    if (this._pendingCb) {
+      this._pendingCb.cancel()
+      this._pendingCb = null
+    }
+  },
+
+  /**
+   * Instantiate/insert a new child vm.
+   * If keep alive and has cached instance, insert that
+   * instance; otherwise build a new one and cache it.
+   *
+   * @param {Object} [data]
+   * @return {Vue} - the created instance
+   */
+
+  build: function (data) {
+    if (this.keepAlive) {
+      var cached = this.cache[this.componentID]
+      if (cached) {
+        return cached
+      }
+    }
+    if (this.Component) {
+      var parent = this._host || this.vm
+      var el = templateParser.clone(this.el)
+      var child = parent.$addChild({
+        el: el,
+        data: data,
+        template: this.template,
+        // if no inline-template, then the compiled
+        // linker can be cached for better performance.
+        _linkerCachable: !this.template,
+        _asComponent: true,
+        _isRouterView: this._isRouterView,
+        _context: this.vm
+      }, this.Component)
+      if (this.keepAlive) {
+        this.cache[this.componentID] = child
+      }
+      return child
+    }
+  },
+
+  /**
+   * Teardown the current child, but defers cleanup so
+   * that we can separate the destroy and removal steps.
+   *
+   * @param {Boolean} defer
+   */
+
+  unbuild: function (defer) {
+    var child = this.childVM
+    if (!child || this.keepAlive) {
+      return
+    }
+    // the sole purpose of `deferCleanup` is so that we can
+    // "deactivate" the vm right now and perform DOM removal
+    // later.
+    child.$destroy(false, defer)
+  },
+
+  /**
+   * Remove current destroyed child and manually do
+   * the cleanup after removal.
+   *
+   * @param {Function} cb
+   */
+
+  remove: function (child, cb) {
+    var keepAlive = this.keepAlive
+    if (child) {
+      child.$remove(function () {
+        if (!keepAlive) child._cleanup()
+        if (cb) cb()
+      })
+    } else if (cb) {
+      cb()
+    }
+  },
+
+  /**
+   * Actually swap the components, depending on the
+   * transition mode. Defaults to simultaneous.
+   *
+   * @param {Vue} target
+   * @param {Function} [cb]
+   */
+
+  transition: function (target, cb) {
+    var self = this
+    var current = this.childVM
+    this.unsetCurrent()
+    this.setCurrent(target)
+    switch (self.transMode) {
+      case 'in-out':
+        target.$before(self.anchor, function () {
+          self.remove(current, cb)
+        })
+        break
+      case 'out-in':
+        self.remove(current, function () {
+          if (!target._isDestroyed) {
+            target.$before(self.anchor, cb)
+          }
+        })
+        break
+      default:
+        self.remove(current)
+        target.$before(self.anchor, cb)
+    }
+  },
+
+  /**
+   * Set childVM and parent ref
+   */
+
+  setCurrent: function (child) {
+    this.childVM = child
+    var refID = child._refID || this.refID
+    if (refID) {
+      this.vm.$[refID] = child
+    }
+  },
+
+  /**
+   * Unset childVM and parent ref
+   */
+
+  unsetCurrent: function () {
+    var child = this.childVM
+    this.childVM = null
+    var refID = (child && child._refID) || this.refID
+    if (refID) {
+      this.vm.$[refID] = null
+    }
+  },
+
+  /**
+   * Unbind.
+   */
+
+  unbind: function () {
+    this.invalidatePending()
+    // Do not defer cleanup when unbinding
+    this.unbuild()
+    this.unsetCurrent()
+    // destroy all keep-alive cached instances
+    if (this.cache) {
+      for (var key in this.cache) {
+        this.cache[key].$destroy()
+      }
+      this.cache = null
+    }
+  }
+}

data/skeleton/vendor/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/skeleton/vendor/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/skeleton/vendor/vue/src/directives/if.js

@@ -0,0 +1,126 @@
+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
+          this._host // important
+        )
+        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)
+    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.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/skeleton/vendor/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/skeleton/vendor/vue/src/directives/model/checkbox.js

@@ -0,0 +1,24 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    this.listener = function () {
+      self.set(el.checked)
+    }
+    _.on(el, 'change', this.listener)
+    if (el.checked) {
+      this._initValue = el.checked
+    }
+  },
+
+  update: function (value) {
+    this.el.checked = !!value
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+  }
+}

data/skeleton/vendor/vue/src/directives/model/index.js

@@ -0,0 +1,76 @@
+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
+    }
+    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
+      }
+    }
+  }
+}

data/skeleton/vendor/vue/src/directives/model/radio.js

@@ -0,0 +1,26 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    this.listener = function () {
+      self.set(el.value)
+    }
+    _.on(el, 'change', this.listener)
+    if (el.checked) {
+      this._initValue = el.value
+    }
+  },
+
+  update: function (value) {
+    /* eslint-disable eqeqeq */
+    this.el.checked = value == this.el.value
+    /* eslint-enable eqeqeq */
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+  }
+}