plate-lang 0.1.0

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

@@ -0,0 +1,199 @@
+var _ = require('../../util')
+var Watcher = require('../../watcher')
+var dirParser = require('../../parsers/directive')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+    // update DOM using latest value.
+    this.forceUpdate = function () {
+      if (self._watcher) {
+        self.update(self._watcher.get())
+      }
+    }
+    // check options param
+    var optionsParam = this._checkParam('options')
+    if (optionsParam) {
+      initOptions.call(this, optionsParam)
+    }
+    this.number = this._checkParam('number') != null
+    this.multiple = el.hasAttribute('multiple')
+    this.listener = function () {
+      var value = self.multiple
+        ? getMultiValue(el)
+        : el.value
+      value = self.number
+        ? _.isArray(value)
+          ? value.map(_.toNumber)
+          : _.toNumber(value)
+        : value
+      self.set(value)
+    }
+    _.on(el, 'change', this.listener)
+    checkInitialValue.call(this)
+    // All major browsers except Firefox resets
+    // selectedIndex with value -1 to 0 when the element
+    // is appended to a new parent, therefore we have to
+    // force a DOM update whenever that happens...
+    this.vm.$on('hook:attached', this.forceUpdate)
+  },
+
+  update: function (value) {
+    var el = this.el
+    el.selectedIndex = -1
+    var multi = this.multiple && _.isArray(value)
+    var options = el.options
+    var i = options.length
+    var option
+    while (i--) {
+      option = options[i]
+      /* eslint-disable eqeqeq */
+      option.selected = multi
+        ? indexOf(value, option.value) > -1
+        : value == option.value
+      /* eslint-enable eqeqeq */
+    }
+  },
+
+  unbind: function () {
+    _.off(this.el, 'change', this.listener)
+    this.vm.$off('hook:attached', this.forceUpdate)
+    if (this.optionWatcher) {
+      this.optionWatcher.teardown()
+    }
+  }
+
+}
+
+/**
+ * Initialize the option list from the param.
+ *
+ * @param {String} expression
+ */
+
+function initOptions (expression) {
+  var self = this
+  var descriptor = dirParser.parse(expression)[0]
+  function optionUpdateWatcher (value) {
+    if (_.isArray(value)) {
+      self.el.innerHTML = ''
+      buildOptions(self.el, value)
+      self.forceUpdate()
+    } else {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Invalid options value for v-model: ' + value
+      )
+    }
+  }
+  this.optionWatcher = new Watcher(
+    this.vm,
+    descriptor.expression,
+    optionUpdateWatcher,
+    {
+      deep: true,
+      filters: descriptor.filters
+    }
+  )
+  // update with initial value
+  optionUpdateWatcher(this.optionWatcher.value)
+}
+
+/**
+ * Build up option elements. IE9 doesn't create options
+ * when setting innerHTML on <select> elements, so we have
+ * to use DOM API here.
+ *
+ * @param {Element} parent - a <select> or an <optgroup>
+ * @param {Array} options
+ */
+
+function buildOptions (parent, options) {
+  var op, el
+  for (var i = 0, l = options.length; i < l; i++) {
+    op = options[i]
+    if (!op.options) {
+      el = document.createElement('option')
+      if (typeof op === 'string') {
+        el.text = el.value = op
+      } else {
+        if (op.value != null) {
+          el.value = op.value
+        }
+        el.text = op.text || op.value || ''
+        if (op.disabled) {
+          el.disabled = true
+        }
+      }
+    } else {
+      el = document.createElement('optgroup')
+      el.label = op.label
+      buildOptions(el, op.options)
+    }
+    parent.appendChild(el)
+  }
+}
+
+/**
+ * Check the initial value for selected options.
+ */
+
+function checkInitialValue () {
+  var initValue
+  var options = this.el.options
+  for (var i = 0, l = options.length; i < l; i++) {
+    if (options[i].hasAttribute('selected')) {
+      if (this.multiple) {
+        (initValue || (initValue = []))
+          .push(options[i].value)
+      } else {
+        initValue = options[i].value
+      }
+    }
+  }
+  if (typeof initValue !== 'undefined') {
+    this._initValue = this.number
+      ? _.toNumber(initValue)
+      : initValue
+  }
+}
+
+/**
+ * Helper to extract a value array for select[multiple]
+ *
+ * @param {SelectElement} el
+ * @return {Array}
+ */
+
+function getMultiValue (el) {
+  return Array.prototype.filter
+    .call(el.options, filterSelected)
+    .map(getOptionValue)
+}
+
+function filterSelected (op) {
+  return op.selected
+}
+
+function getOptionValue (op) {
+  return op.value || op.text
+}
+
+/**
+ * Native Array.indexOf uses strict equal, but in this
+ * case we need to match string/numbers with soft equal.
+ *
+ * @param {Array} arr
+ * @param {*} val
+ */
+
+function indexOf (arr, val) {
+  var i = arr.length
+  while (i--) {
+    /* eslint-disable eqeqeq */
+    if (arr[i] == val) return i
+    /* eslint-enable eqeqeq */
+  }
+  return -1
+}

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

@@ -0,0 +1,159 @@
+var _ = require('../../util')
+
+module.exports = {
+
+  bind: function () {
+    var self = this
+    var el = this.el
+
+    // check params
+    // - lazy: update model on "change" instead of "input"
+    var lazy = this._checkParam('lazy') != null
+    // - number: cast value into number when updating model.
+    var number = this._checkParam('number') != null
+    // - debounce: debounce the input listener
+    var debounce = parseInt(this._checkParam('debounce'), 10)
+
+    // handle composition events.
+    //   http://blog.evanyou.me/2014/01/03/composition-event/
+    // skip this for Android because it handles composition
+    // events quite differently. Android doesn't trigger
+    // composition events for language input methods e.g.
+    // Chinese, but instead triggers them for spelling
+    // suggestions... (see Discussion/#162)
+    var composing = false
+    if (!_.isAndroid) {
+      this.onComposeStart = function () {
+        composing = true
+      }
+      this.onComposeEnd = function () {
+        composing = false
+        // in IE11 the "compositionend" event fires AFTER
+        // the "input" event, so the input handler is blocked
+        // at the end... have to call it here.
+        self.listener()
+      }
+      _.on(el, 'compositionstart', this.onComposeStart)
+      _.on(el, 'compositionend', this.onComposeEnd)
+    }
+
+    function syncToModel () {
+      var val = number
+        ? _.toNumber(el.value)
+        : el.value
+      self.set(val)
+    }
+
+    // if the directive has filters, we need to
+    // record cursor position and restore it after updating
+    // the input with the filtered value.
+    // also force update for type="range" inputs to enable
+    // "lock in range" (see #506)
+    if (this.hasRead || el.type === 'range') {
+      this.listener = function () {
+        if (composing) return
+        var charsOffset
+        // some HTML5 input types throw error here
+        try {
+          // record how many chars from the end of input
+          // the cursor was at
+          charsOffset = el.value.length - el.selectionStart
+        } catch (e) {}
+        // Fix IE10/11 infinite update cycle
+        // https://github.com/yyx990803/vue/issues/592
+        /* istanbul ignore if */
+        if (charsOffset < 0) {
+          return
+        }
+        syncToModel()
+        _.nextTick(function () {
+          // force a value update, because in
+          // certain cases the write filters output the
+          // same result for different input values, and
+          // the Observer set events won't be triggered.
+          var newVal = self._watcher.value
+          self.update(newVal)
+          if (charsOffset != null) {
+            var cursorPos =
+              _.toString(newVal).length - charsOffset
+            el.setSelectionRange(cursorPos, cursorPos)
+          }
+        })
+      }
+    } else {
+      this.listener = function () {
+        if (composing) return
+        syncToModel()
+      }
+    }
+
+    if (debounce) {
+      this.listener = _.debounce(this.listener, debounce)
+    }
+
+    // Now attach the main listener
+
+    this.event = lazy ? 'change' : 'input'
+    // Support jQuery events, since jQuery.trigger() doesn't
+    // trigger native events in some cases and some plugins
+    // rely on $.trigger()
+    //
+    // We want to make sure if a listener is attached using
+    // jQuery, it is also removed with jQuery, that's why
+    // we do the check for each directive instance and
+    // store that check result on itself. This also allows
+    // easier test coverage control by unsetting the global
+    // jQuery variable in tests.
+    this.hasjQuery = typeof jQuery === 'function'
+    if (this.hasjQuery) {
+      jQuery(el).on(this.event, this.listener)
+    } else {
+      _.on(el, this.event, this.listener)
+    }
+
+    // IE9 doesn't fire input event on backspace/del/cut
+    if (!lazy && _.isIE9) {
+      this.onCut = function () {
+        _.nextTick(self.listener)
+      }
+      this.onDel = function (e) {
+        if (e.keyCode === 46 || e.keyCode === 8) {
+          self.listener()
+        }
+      }
+      _.on(el, 'cut', this.onCut)
+      _.on(el, 'keyup', this.onDel)
+    }
+
+    // set initial value if present
+    if (
+      el.hasAttribute('value') ||
+      (el.tagName === 'TEXTAREA' && el.value.trim())
+    ) {
+      this._initValue = number
+        ? _.toNumber(el.value)
+        : el.value
+    }
+  },
+
+  update: function (value) {
+    this.el.value = _.toString(value)
+  },
+
+  unbind: function () {
+    var el = this.el
+    if (this.hasjQuery) {
+      jQuery(el).off(this.event, this.listener)
+    } else {
+      _.off(el, this.event, this.listener)
+    }
+    if (this.onComposeStart) {
+      _.off(el, 'compositionstart', this.onComposeStart)
+      _.off(el, 'compositionend', this.onComposeEnd)
+    }
+    if (this.onCut) {
+      _.off(el, 'cut', this.onCut)
+      _.off(el, 'keyup', this.onDel)
+    }
+  }
+}

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

@@ -0,0 +1,60 @@
+var _ = require('../util')
+
+module.exports = {
+
+  acceptStatement: true,
+  priority: 700,
+
+  bind: function () {
+    // deal with iframes
+    if (
+      this.el.tagName === 'IFRAME' &&
+      this.arg !== 'load'
+    ) {
+      var self = this
+      this.iframeBind = function () {
+        _.on(self.el.contentWindow, self.arg, self.handler)
+      }
+      _.on(this.el, 'load', this.iframeBind)
+    }
+  },
+
+  update: function (handler) {
+    if (typeof handler !== 'function') {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'Directive v-on="' + this.arg + ': ' +
+        this.expression + '" expects a function value, ' +
+        'got ' + handler
+      )
+      return
+    }
+    this.reset()
+    var vm = this.vm
+    this.handler = function (e) {
+      e.targetVM = vm
+      vm.$event = e
+      var res = handler(e)
+      vm.$event = null
+      return res
+    }
+    if (this.iframeBind) {
+      this.iframeBind()
+    } else {
+      _.on(this.el, this.arg, this.handler)
+    }
+  },
+
+  reset: function () {
+    var el = this.iframeBind
+      ? this.el.contentWindow
+      : this.el
+    if (this.handler) {
+      _.off(el, this.arg, this.handler)
+    }
+  },
+
+  unbind: function () {
+    this.reset()
+    _.off(this.el, 'load', this.iframeBind)
+  }
+}

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

@@ -0,0 +1,62 @@
+// NOTE: the prop internal directive is compiled and linked
+// during _initScope(), before the created hook is called.
+// The purpose is to make the initial prop values available
+// inside `created` hooks and `data` functions.
+
+var _ = require('../util')
+var Watcher = require('../watcher')
+var bindingModes = require('../config')._propBindingModes
+
+module.exports = {
+
+  bind: function () {
+
+    var child = this.vm
+    var parent = child._context
+    // passed in from compiler directly
+    var prop = this._descriptor
+    var childKey = prop.path
+    var parentKey = prop.parentPath
+
+    this.parentWatcher = new Watcher(
+      parent,
+      parentKey,
+      function (val) {
+        if (_.assertProp(prop, val)) {
+          child[childKey] = val
+        }
+      }
+    )
+
+    // set the child initial value.
+    var value = this.parentWatcher.value
+    if (childKey === '$data') {
+      child._data = value
+    } else {
+      _.initProp(child, prop, value)
+    }
+
+    // setup two-way binding
+    if (prop.mode === bindingModes.TWO_WAY) {
+      // important: defer the child watcher creation until
+      // the created hook (after data observation)
+      var self = this
+      child.$once('hook:created', function () {
+        self.childWatcher = new Watcher(
+          child,
+          childKey,
+          function (val) {
+            parent.$set(parentKey, val)
+          }
+        )
+      })
+    }
+  },
+
+  unbind: function () {
+    this.parentWatcher.teardown()
+    if (this.childWatcher) {
+      this.childWatcher.teardown()
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+var _ = require('../util')
+
+module.exports = {
+
+  isLiteral: true,
+
+  bind: function () {
+    var vm = this.el.__vue__
+    if (!vm) {
+      process.env.NODE_ENV !== 'production' && _.warn(
+        'v-ref should only be used on a component root element.'
+      )
+      return
+    }
+    // If we get here, it means this is a `v-ref` on a
+    // child, because parent scope `v-ref` is stripped in
+    // `v-component` already. So we just record our own ref
+    // here - it will overwrite parent ref in `v-component`,
+    // if any.
+    vm._refID = this.expression
+  }
+}