plate-lang 0.1.0

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

@@ -0,0 +1,8 @@
+var transition = require('../transition')
+
+module.exports = function (value) {
+  var el = this.el
+  transition.apply(el, value ? 1 : -1, function () {
+    el.style.display = value ? '' : 'none'
+  }, this.vm)
+}

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

@@ -0,0 +1,110 @@
+var _ = require('../util')
+var prefixes = ['-webkit-', '-moz-', '-ms-']
+var camelPrefixes = ['Webkit', 'Moz', 'ms']
+var importantRE = /!important;?$/
+var camelRE = /([a-z])([A-Z])/g
+var testEl = null
+var propCache = {}
+
+module.exports = {
+
+  deep: true,
+
+  update: function (value) {
+    if (this.arg) {
+      this.setProp(this.arg, value)
+    } else {
+      if (typeof value === 'object') {
+        this.objectHandler(value)
+      } else {
+        this.el.style.cssText = value
+      }
+    }
+  },
+
+  objectHandler: function (value) {
+    // cache object styles so that only changed props
+    // are actually updated.
+    var cache = this.cache || (this.cache = {})
+    var prop, val
+    for (prop in cache) {
+      if (!(prop in value)) {
+        this.setProp(prop, null)
+        delete cache[prop]
+      }
+    }
+    for (prop in value) {
+      val = value[prop]
+      if (val !== cache[prop]) {
+        cache[prop] = val
+        this.setProp(prop, val)
+      }
+    }
+  },
+
+  setProp: function (prop, value) {
+    prop = normalize(prop)
+    if (!prop) return // unsupported prop
+    // cast possible numbers/booleans into strings
+    if (value != null) value += ''
+    if (value) {
+      var isImportant = importantRE.test(value)
+        ? 'important'
+        : ''
+      if (isImportant) {
+        value = value.replace(importantRE, '').trim()
+      }
+      this.el.style.setProperty(prop, value, isImportant)
+    } else {
+      this.el.style.removeProperty(prop)
+    }
+  }
+
+}
+
+/**
+ * Normalize a CSS property name.
+ * - cache result
+ * - auto prefix
+ * - camelCase -> dash-case
+ *
+ * @param {String} prop
+ * @return {String}
+ */
+
+function normalize (prop) {
+  if (propCache[prop]) {
+    return propCache[prop]
+  }
+  var res = prefix(prop)
+  propCache[prop] = propCache[res] = res
+  return res
+}
+
+/**
+ * Auto detect the appropriate prefix for a CSS property.
+ * https://gist.github.com/paulirish/523692
+ *
+ * @param {String} prop
+ * @return {String}
+ */
+
+function prefix (prop) {
+  prop = prop.replace(camelRE, '$1-$2').toLowerCase()
+  var camel = _.camelize(prop)
+  var upper = camel.charAt(0).toUpperCase() + camel.slice(1)
+  if (!testEl) {
+    testEl = document.createElement('div')
+  }
+  if (camel in testEl.style) {
+    return prop
+  }
+  var i = prefixes.length
+  var prefixed
+  while (i--) {
+    prefixed = camelPrefixes[i] + upper
+    if (prefixed in testEl.style) {
+      return prefixes[i] + prop
+    }
+  }
+}

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

@@ -0,0 +1,14 @@
+var _ = require('../util')
+
+module.exports = {
+
+  bind: function () {
+    this.attr = this.el.nodeType === 3
+      ? 'data'
+      : 'textContent'
+  },
+
+  update: function (value) {
+    this.el[this.attr] = _.toString(value)
+  }
+}

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

@@ -0,0 +1,26 @@
+var _ = require('../util')
+var Transition = require('../transition/transition')
+
+module.exports = {
+
+  priority: 1000,
+  isLiteral: true,
+
+  bind: function () {
+    if (!this._isDynamicLiteral) {
+      this.update(this.expression)
+    }
+  },
+
+  update: function (id, oldId) {
+    var el = this.el
+    var vm = this.el.__vue__ || this.vm
+    var hooks = _.resolveAsset(vm.$options, 'transitions', id)
+    id = id || 'v'
+    el.__v_trans = new Transition(el, id, hooks, vm)
+    if (oldId) {
+      _.removeClass(el, oldId + '-transition')
+    }
+    _.addClass(el, id + '-transition')
+  }
+}

data/skeleton/vendor/vue/src/element-directives/content.js

@@ -0,0 +1,111 @@
+var _ = require('../util')
+var clone = require('../parsers/template').clone
+
+// This is the elementDirective that handles <content>
+// transclusions. It relies on the raw content of an
+// instance being stored as `$options._content` during
+// the transclude phase.
+
+module.exports = {
+
+  bind: function () {
+    var vm = this.vm
+    var host = vm
+    // we need find the content context, which is the
+    // closest non-inline-repeater instance.
+    while (host.$options._repeat) {
+      host = host.$parent
+    }
+    var raw = host.$options._content
+    var content
+    if (!raw) {
+      this.fallback()
+      return
+    }
+    var context = host._context
+    var selector = this._checkParam('select')
+    if (!selector) {
+      // Default content
+      var self = this
+      var compileDefaultContent = function () {
+        self.compile(
+          extractFragment(raw.childNodes, raw, true),
+          context,
+          vm
+        )
+      }
+      if (!host._isCompiled) {
+        // defer until the end of instance compilation,
+        // because the default outlet must wait until all
+        // other possible outlets with selectors have picked
+        // out their contents.
+        host.$once('hook:compiled', compileDefaultContent)
+      } else {
+        compileDefaultContent()
+      }
+    } else {
+      // select content
+      var nodes = raw.querySelectorAll(selector)
+      if (nodes.length) {
+        content = extractFragment(nodes, raw)
+        if (content.hasChildNodes()) {
+          this.compile(content, context, vm)
+        } else {
+          this.fallback()
+        }
+      } else {
+        this.fallback()
+      }
+    }
+  },
+
+  fallback: function () {
+    this.compile(_.extractContent(this.el, true), this.vm)
+  },
+
+  compile: function (content, context, host) {
+    if (content && context) {
+      this.unlink = context.$compile(content, host)
+    }
+    if (content) {
+      _.replace(this.el, content)
+    } else {
+      _.remove(this.el)
+    }
+  },
+
+  unbind: function () {
+    if (this.unlink) {
+      this.unlink()
+    }
+  }
+}
+
+/**
+ * Extract qualified content nodes from a node list.
+ *
+ * @param {NodeList} nodes
+ * @param {Element} parent
+ * @param {Boolean} main
+ * @return {DocumentFragment}
+ */
+
+function extractFragment (nodes, parent, main) {
+  var frag = document.createDocumentFragment()
+  for (var i = 0, l = nodes.length; i < l; i++) {
+    var node = nodes[i]
+    // if this is the main outlet, we want to skip all
+    // previously selected nodes;
+    // otherwise, we want to mark the node as selected.
+    // clone the node so the original raw content remains
+    // intact. this ensures proper re-compilation in cases
+    // where the outlet is inside a conditional block
+    if (main && !node.__v_selected) {
+      frag.appendChild(clone(node))
+    } else if (!main && node.parentNode === parent) {
+      node.__v_selected = true
+      frag.appendChild(clone(node))
+    }
+  }
+  return frag
+}

data/skeleton/vendor/vue/src/element-directives/index.js

@@ -0,0 +1,2 @@
+exports.content = require('./content')
+exports.partial = require('./partial')

data/skeleton/vendor/vue/src/element-directives/partial.js

@@ -0,0 +1,73 @@
+var _ = require('../util')
+var templateParser = require('../parsers/template')
+var textParser = require('../parsers/text')
+var compiler = require('../compiler')
+var Cache = require('../cache')
+var cache = new Cache(1000)
+
+// v-partial reuses logic from v-if
+var vIf = require('../directives/if')
+
+module.exports = {
+
+  link: vIf.link,
+  teardown: vIf.teardown,
+  getContainedComponents: vIf.getContainedComponents,
+
+  bind: function () {
+    var el = this.el
+    this.start = _.createAnchor('v-partial-start')
+    this.end = _.createAnchor('v-partial-end')
+    _.replace(el, this.end)
+    _.before(this.start, this.end)
+    var id = el.getAttribute('name')
+    var tokens = textParser.parse(id)
+    if (tokens) {
+      // dynamic partial
+      this.setupDynamic(tokens)
+    } else {
+      // static partial
+      this.insert(id)
+    }
+  },
+
+  setupDynamic: function (tokens) {
+    var self = this
+    var exp = textParser.tokensToExp(tokens)
+    this.unwatch = this.vm.$watch(exp, function (value) {
+      self.teardown()
+      self.insert(value)
+    }, {
+      immediate: true,
+      user: false
+    })
+  },
+
+  insert: function (id) {
+    var partial = _.resolveAsset(this.vm.$options, 'partials', id)
+    if (process.env.NODE_ENV !== 'production') {
+      _.assertAsset(partial, 'partial', id)
+    }
+    if (partial) {
+      var frag = templateParser.parse(partial, true)
+      // cache partials based on constructor id.
+      var cacheId = (this.vm.constructor.cid || '') + partial
+      var linker = this.compile(frag, cacheId)
+      // this is provided by v-if
+      this.link(frag, linker)
+    }
+  },
+
+  compile: function (frag, cacheId) {
+    var hit = cache.get(cacheId)
+    if (hit) return hit
+    var linker = compiler.compile(frag, this.vm.$options, true)
+    cache.put(cacheId, linker)
+    return linker
+  },
+
+  unbind: function () {
+    if (this.unlink) this.unlink()
+    if (this.unwatch) this.unwatch()
+  }
+}

data/skeleton/vendor/vue/src/filters/array-filters.js

@@ -0,0 +1,85 @@
+var _ = require('../util')
+var Path = require('../parsers/path')
+
+/**
+ * Filter filter for v-repeat
+ *
+ * @param {String} searchKey
+ * @param {String} [delimiter]
+ * @param {String} dataKey
+ */
+
+exports.filterBy = function (arr, search, delimiter, dataKey) {
+  // allow optional `in` delimiter
+  // because why not
+  if (delimiter && delimiter !== 'in') {
+    dataKey = delimiter
+  }
+  if (search == null) {
+    return arr
+  }
+  // cast to lowercase string
+  search = ('' + search).toLowerCase()
+  return arr.filter(function (item) {
+    return dataKey
+      ? contains(Path.get(item, dataKey), search)
+      : contains(item, search)
+  })
+}
+
+/**
+ * Filter filter for v-repeat
+ *
+ * @param {String} sortKey
+ * @param {String} reverse
+ */
+
+exports.orderBy = function (arr, sortKey, reverse) {
+  if (!sortKey) {
+    return arr
+  }
+  var order = 1
+  if (arguments.length > 2) {
+    if (reverse === '-1') {
+      order = -1
+    } else {
+      order = reverse ? -1 : 1
+    }
+  }
+  // sort on a copy to avoid mutating original array
+  return arr.slice().sort(function (a, b) {
+    if (sortKey !== '$key' && sortKey !== '$value') {
+      if (a && '$value' in a) a = a.$value
+      if (b && '$value' in b) b = b.$value
+    }
+    a = _.isObject(a) ? Path.get(a, sortKey) : a
+    b = _.isObject(b) ? Path.get(b, sortKey) : b
+    return a === b ? 0 : a > b ? order : -order
+  })
+}
+
+/**
+ * String contain helper
+ *
+ * @param {*} val
+ * @param {String} search
+ */
+
+function contains (val, search) {
+  if (_.isPlainObject(val)) {
+    for (var key in val) {
+      if (contains(val[key], search)) {
+        return true
+      }
+    }
+  } else if (_.isArray(val)) {
+    var i = val.length
+    while (i--) {
+      if (contains(val[i], search)) {
+        return true
+      }
+    }
+  } else if (val != null) {
+    return val.toString().toLowerCase().indexOf(search) > -1
+  }
+}

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

@@ -0,0 +1,137 @@
+var _ = require('../util')
+
+/**
+ * Stringify value.
+ *
+ * @param {Number} indent
+ */
+
+exports.json = {
+  read: function (value, indent) {
+    return typeof value === 'string'
+      ? value
+      : JSON.stringify(value, null, Number(indent) || 2)
+  },
+  write: function (value) {
+    try {
+      return JSON.parse(value)
+    } catch (e) {
+      return value
+    }
+  }
+}
+
+/**
+ * 'abc' => 'Abc'
+ */
+
+exports.capitalize = function (value) {
+  if (!value && value !== 0) return ''
+  value = value.toString()
+  return value.charAt(0).toUpperCase() + value.slice(1)
+}
+
+/**
+ * 'abc' => 'ABC'
+ */
+
+exports.uppercase = function (value) {
+  return (value || value === 0)
+    ? value.toString().toUpperCase()
+    : ''
+}
+
+/**
+ * 'AbC' => 'abc'
+ */
+
+exports.lowercase = function (value) {
+  return (value || value === 0)
+    ? value.toString().toLowerCase()
+    : ''
+}
+
+/**
+ * 12345 => $12,345.00
+ *
+ * @param {String} sign
+ */
+
+var digitsRE = /(\d{3})(?=\d)/g
+exports.currency = function (value, currency) {
+  value = parseFloat(value)
+  if (!isFinite(value) || (!value && value !== 0)) return ''
+  currency = currency || '$'
+  var stringified = Math.abs(value).toFixed(2)
+  var _int = stringified.slice(0, -3)
+  var i = _int.length % 3
+  var head = i > 0
+    ? (_int.slice(0, i) + (_int.length > 3 ? ',' : ''))
+    : ''
+  var _float = stringified.slice(-3)
+  var sign = value < 0 ? '-' : ''
+  return currency + sign + head +
+    _int.slice(i).replace(digitsRE, '$1,') +
+    _float
+}
+
+/**
+ * 'item' => 'items'
+ *
+ * @params
+ *  an array of strings corresponding to
+ *  the single, double, triple ... forms of the word to
+ *  be pluralized. When the number to be pluralized
+ *  exceeds the length of the args, it will use the last
+ *  entry in the array.
+ *
+ *  e.g. ['single', 'double', 'triple', 'multiple']
+ */
+
+exports.pluralize = function (value) {
+  var args = _.toArray(arguments, 1)
+  return args.length > 1
+    ? (args[value % 10 - 1] || args[args.length - 1])
+    : (args[0] + (value === 1 ? '' : 's'))
+}
+
+/**
+ * A special filter that takes a handler function,
+ * wraps it so it only gets triggered on specific
+ * keypresses. v-on only.
+ *
+ * @param {String} key
+ */
+
+var keyCodes = {
+  esc: 27,
+  tab: 9,
+  enter: 13,
+  'delete': 46,
+  up: 38,
+  left: 37,
+  right: 39,
+  down: 40
+}
+
+exports.key = function (handler, key) {
+  if (!handler) return
+  var code = keyCodes[key]
+  if (!code) {
+    code = parseInt(key, 10)
+  }
+  return function (e) {
+    if (e.keyCode === code) {
+      return handler.call(this, e)
+    }
+  }
+}
+
+// expose keycode hash
+exports.key.keyCodes = keyCodes
+
+/**
+ * Install special array filters
+ */
+
+_.extend(exports, require('./array-filters'))