plate-lang 0.1.0

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

@@ -0,0 +1,176 @@
+var Cache = require('../cache')
+var config = require('../config')
+var dirParser = require('./directive')
+var regexEscapeRE = /[-.*+?^${}()|[\]\/\\]/g
+var cache, tagRE, htmlRE, firstChar, lastChar
+
+/**
+ * Escape a string so it can be used in a RegExp
+ * constructor.
+ *
+ * @param {String} str
+ */
+
+function escapeRegex (str) {
+  return str.replace(regexEscapeRE, '\\$&')
+}
+
+/**
+ * Compile the interpolation tag regex.
+ *
+ * @return {RegExp}
+ */
+
+function compileRegex () {
+  config._delimitersChanged = false
+  var open = config.delimiters[0]
+  var close = config.delimiters[1]
+  firstChar = open.charAt(0)
+  lastChar = close.charAt(close.length - 1)
+  var firstCharRE = escapeRegex(firstChar)
+  var lastCharRE = escapeRegex(lastChar)
+  var openRE = escapeRegex(open)
+  var closeRE = escapeRegex(close)
+  tagRE = new RegExp(
+    firstCharRE + '?' + openRE +
+    '(.+?)' +
+    closeRE + lastCharRE + '?',
+    'g'
+  )
+  htmlRE = new RegExp(
+    '^' + firstCharRE + openRE +
+    '.*' +
+    closeRE + lastCharRE + '$'
+  )
+  // reset cache
+  cache = new Cache(1000)
+}
+
+/**
+ * Parse a template text string into an array of tokens.
+ *
+ * @param {String} text
+ * @return {Array<Object> | null}
+ *               - {String} type
+ *               - {String} value
+ *               - {Boolean} [html]
+ *               - {Boolean} [oneTime]
+ */
+
+exports.parse = function (text) {
+  if (config._delimitersChanged) {
+    compileRegex()
+  }
+  var hit = cache.get(text)
+  if (hit) {
+    return hit
+  }
+  text = text.replace(/\n/g, '')
+  if (!tagRE.test(text)) {
+    return null
+  }
+  var tokens = []
+  var lastIndex = tagRE.lastIndex = 0
+  var match, index, value, first, oneTime, twoWay
+  /* eslint-disable no-cond-assign */
+  while (match = tagRE.exec(text)) {
+  /* eslint-enable no-cond-assign */
+    index = match.index
+    // push text token
+    if (index > lastIndex) {
+      tokens.push({
+        value: text.slice(lastIndex, index)
+      })
+    }
+    // tag token
+    first = match[1].charCodeAt(0)
+    oneTime = first === 42 // *
+    twoWay = first === 64  // @
+    value = oneTime || twoWay
+      ? match[1].slice(1)
+      : match[1]
+    tokens.push({
+      tag: true,
+      value: value.trim(),
+      html: htmlRE.test(match[0]),
+      oneTime: oneTime,
+      twoWay: twoWay
+    })
+    lastIndex = index + match[0].length
+  }
+  if (lastIndex < text.length) {
+    tokens.push({
+      value: text.slice(lastIndex)
+    })
+  }
+  cache.put(text, tokens)
+  return tokens
+}
+
+/**
+ * Format a list of tokens into an expression.
+ * e.g. tokens parsed from 'a {{b}} c' can be serialized
+ * into one single expression as '"a " + b + " c"'.
+ *
+ * @param {Array} tokens
+ * @param {Vue} [vm]
+ * @return {String}
+ */
+
+exports.tokensToExp = function (tokens, vm) {
+  return tokens.length > 1
+    ? tokens.map(function (token) {
+        return formatToken(token, vm)
+      }).join('+')
+    : formatToken(tokens[0], vm, true)
+}
+
+/**
+ * Format a single token.
+ *
+ * @param {Object} token
+ * @param {Vue} [vm]
+ * @param {Boolean} single
+ * @return {String}
+ */
+
+function formatToken (token, vm, single) {
+  return token.tag
+    ? vm && token.oneTime
+      ? '"' + vm.$eval(token.value) + '"'
+      : inlineFilters(token.value, single)
+    : '"' + token.value + '"'
+}
+
+/**
+ * For an attribute with multiple interpolation tags,
+ * e.g. attr="some-{{thing | filter}}", in order to combine
+ * the whole thing into a single watchable expression, we
+ * have to inline those filters. This function does exactly
+ * that. This is a bit hacky but it avoids heavy changes
+ * to directive parser and watcher mechanism.
+ *
+ * @param {String} exp
+ * @param {Boolean} single
+ * @return {String}
+ */
+
+var filterRE = /[^|]\|[^|]/
+function inlineFilters (exp, single) {
+  if (!filterRE.test(exp)) {
+    return single
+      ? exp
+      : '(' + exp + ')'
+  } else {
+    var dir = dirParser.parse(exp)[0]
+    if (!dir.filters) {
+      return '(' + exp + ')'
+    } else {
+      return 'this._applyFilters(' +
+        dir.expression + // value
+        ',null,' +       // oldValue (null for read)
+        JSON.stringify(dir.filters) + // filter descriptors
+        ',false)'        // write?
+    }
+  }
+}

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

@@ -0,0 +1,128 @@
+var _ = require('../util')
+
+/**
+ * Append with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.append = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * InsertBefore with transition.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.before = function (el, target, vm, cb) {
+  apply(el, 1, function () {
+    _.before(el, target)
+  }, vm, cb)
+}
+
+/**
+ * Remove with transition.
+ *
+ * @oaram {Element} el
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.remove = function (el, vm, cb) {
+  apply(el, -1, function () {
+    _.remove(el)
+  }, vm, cb)
+}
+
+/**
+ * Remove by appending to another parent with transition.
+ * This is only used in block operations.
+ *
+ * @oaram {Element} el
+ * @param {Element} target
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+exports.removeThenAppend = function (el, target, vm, cb) {
+  apply(el, -1, function () {
+    target.appendChild(el)
+  }, vm, cb)
+}
+
+/**
+ * Append the childNodes of a fragment to target.
+ *
+ * @param {DocumentFragment} block
+ * @param {Node} target
+ * @param {Vue} vm
+ */
+
+exports.blockAppend = function (block, target, vm) {
+  var nodes = _.toArray(block.childNodes)
+  for (var i = 0, l = nodes.length; i < l; i++) {
+    exports.before(nodes[i], target, vm)
+  }
+}
+
+/**
+ * Remove a block of nodes between two edge nodes.
+ *
+ * @param {Node} start
+ * @param {Node} end
+ * @param {Vue} vm
+ */
+
+exports.blockRemove = function (start, end, vm) {
+  var node = start.nextSibling
+  var next
+  while (node !== end) {
+    next = node.nextSibling
+    exports.remove(node, vm)
+    node = next
+  }
+}
+
+/**
+ * Apply transitions with an operation callback.
+ *
+ * @oaram {Element} el
+ * @param {Number} direction
+ *                  1: enter
+ *                 -1: leave
+ * @param {Function} op - the actual DOM operation
+ * @param {Vue} vm
+ * @param {Function} [cb]
+ */
+
+var apply = exports.apply = function (el, direction, op, vm, cb) {
+  var transition = el.__v_trans
+  if (
+    !transition ||
+    // skip if there are no js hooks and CSS transition is
+    // not supported
+    (!transition.hooks && !_.transitionEndEvent) ||
+    // skip transitions for initial compile
+    !vm._isCompiled ||
+    // if the vm is being manipulated by a parent directive
+    // during the parent's compilation phase, skip the
+    // animation.
+    (vm.$parent && !vm.$parent._isCompiled)
+  ) {
+    op()
+    if (cb) cb()
+    return
+  }
+  var action = direction > 0 ? 'enter' : 'leave'
+  transition[action](op, cb)
+}

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

@@ -0,0 +1,35 @@
+var _ = require('../util')
+var queue = []
+var queued = false
+
+/**
+ * Push a job into the queue.
+ *
+ * @param {Function} job
+ */
+
+exports.push = function (job) {
+  queue.push(job)
+  if (!queued) {
+    queued = true
+    _.nextTick(flush)
+  }
+}
+
+/**
+ * Flush the queue, and do one forced reflow before
+ * triggering transitions.
+ */
+
+function flush () {
+  // Force layout
+  var f = document.documentElement.offsetHeight
+  for (var i = 0; i < queue.length; i++) {
+    queue[i]()
+  }
+  queue = []
+  queued = false
+  // dummy return, so js linters don't complain about
+  // unused variable f
+  return f
+}

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

@@ -0,0 +1,308 @@
+var _ = require('../util')
+var queue = require('./queue')
+var addClass = _.addClass
+var removeClass = _.removeClass
+var transitionEndEvent = _.transitionEndEvent
+var animationEndEvent = _.animationEndEvent
+var transDurationProp = _.transitionProp + 'Duration'
+var animDurationProp = _.animationProp + 'Duration'
+
+var TYPE_TRANSITION = 1
+var TYPE_ANIMATION = 2
+
+/**
+ * A Transition object that encapsulates the state and logic
+ * of the transition.
+ *
+ * @param {Element} el
+ * @param {String} id
+ * @param {Object} hooks
+ * @param {Vue} vm
+ */
+
+function Transition (el, id, hooks, vm) {
+  this.el = el
+  this.enterClass = id + '-enter'
+  this.leaveClass = id + '-leave'
+  this.hooks = hooks
+  this.vm = vm
+  // async state
+  this.pendingCssEvent =
+  this.pendingCssCb =
+  this.cancel =
+  this.pendingJsCb =
+  this.op =
+  this.cb = null
+  this.typeCache = {}
+  // bind
+  var self = this
+  ;['enterNextTick', 'enterDone', 'leaveNextTick', 'leaveDone']
+    .forEach(function (m) {
+      self[m] = _.bind(self[m], self)
+    })
+}
+
+var p = Transition.prototype
+
+/**
+ * Start an entering transition.
+ *
+ * 1. enter transition triggered
+ * 2. call beforeEnter hook
+ * 3. add enter class
+ * 4. insert/show element
+ * 5. call enter hook (with possible explicit js callback)
+ * 6. reflow
+ * 7. based on transition type:
+ *    - transition:
+ *        remove class now, wait for transitionend,
+ *        then done if there's no explicit js callback.
+ *    - animation:
+ *        wait for animationend, remove class,
+ *        then done if there's no explicit js callback.
+ *    - no css transition:
+ *        done now if there's no explicit js callback.
+ * 8. wait for either done or js callback, then call
+ *    afterEnter hook.
+ *
+ * @param {Function} op - insert/show the element
+ * @param {Function} [cb]
+ */
+
+p.enter = function (op, cb) {
+  this.cancelPending()
+  this.callHook('beforeEnter')
+  this.cb = cb
+  addClass(this.el, this.enterClass)
+  op()
+  this.callHookWithCb('enter')
+  this.cancel = this.hooks && this.hooks.enterCancelled
+  queue.push(this.enterNextTick)
+}
+
+/**
+ * The "nextTick" phase of an entering transition, which is
+ * to be pushed into a queue and executed after a reflow so
+ * that removing the class can trigger a CSS transition.
+ */
+
+p.enterNextTick = function () {
+  var type = this.getCssTransitionType(this.enterClass)
+  var enterDone = this.enterDone
+  if (type === TYPE_TRANSITION) {
+    // trigger transition by removing enter class now
+    removeClass(this.el, this.enterClass)
+    this.setupCssCb(transitionEndEvent, enterDone)
+  } else if (type === TYPE_ANIMATION) {
+    this.setupCssCb(animationEndEvent, enterDone)
+  } else if (!this.pendingJsCb) {
+    enterDone()
+  }
+}
+
+/**
+ * The "cleanup" phase of an entering transition.
+ */
+
+p.enterDone = function () {
+  this.cancel = this.pendingJsCb = null
+  removeClass(this.el, this.enterClass)
+  this.callHook('afterEnter')
+  if (this.cb) this.cb()
+}
+
+/**
+ * Start a leaving transition.
+ *
+ * 1. leave transition triggered.
+ * 2. call beforeLeave hook
+ * 3. add leave class (trigger css transition)
+ * 4. call leave hook (with possible explicit js callback)
+ * 5. reflow if no explicit js callback is provided
+ * 6. based on transition type:
+ *    - transition or animation:
+ *        wait for end event, remove class, then done if
+ *        there's no explicit js callback.
+ *    - no css transition:
+ *        done if there's no explicit js callback.
+ * 7. wait for either done or js callback, then call
+ *    afterLeave hook.
+ *
+ * @param {Function} op - remove/hide the element
+ * @param {Function} [cb]
+ */
+
+p.leave = function (op, cb) {
+  this.cancelPending()
+  this.callHook('beforeLeave')
+  this.op = op
+  this.cb = cb
+  addClass(this.el, this.leaveClass)
+  this.callHookWithCb('leave')
+  this.cancel = this.hooks && this.hooks.leaveCancelled
+  // only need to do leaveNextTick if there's no explicit
+  // js callback
+  if (!this.pendingJsCb) {
+    queue.push(this.leaveNextTick)
+  }
+}
+
+/**
+ * The "nextTick" phase of a leaving transition.
+ */
+
+p.leaveNextTick = function () {
+  var type = this.getCssTransitionType(this.leaveClass)
+  if (type) {
+    var event = type === TYPE_TRANSITION
+      ? transitionEndEvent
+      : animationEndEvent
+    this.setupCssCb(event, this.leaveDone)
+  } else {
+    this.leaveDone()
+  }
+}
+
+/**
+ * The "cleanup" phase of a leaving transition.
+ */
+
+p.leaveDone = function () {
+  this.cancel = this.pendingJsCb = null
+  this.op()
+  removeClass(this.el, this.leaveClass)
+  this.callHook('afterLeave')
+  if (this.cb) this.cb()
+}
+
+/**
+ * Cancel any pending callbacks from a previously running
+ * but not finished transition.
+ */
+
+p.cancelPending = function () {
+  this.op = this.cb = null
+  var hasPending = false
+  if (this.pendingCssCb) {
+    hasPending = true
+    _.off(this.el, this.pendingCssEvent, this.pendingCssCb)
+    this.pendingCssEvent = this.pendingCssCb = null
+  }
+  if (this.pendingJsCb) {
+    hasPending = true
+    this.pendingJsCb.cancel()
+    this.pendingJsCb = null
+  }
+  if (hasPending) {
+    removeClass(this.el, this.enterClass)
+    removeClass(this.el, this.leaveClass)
+  }
+  if (this.cancel) {
+    this.cancel.call(this.vm, this.el)
+    this.cancel = null
+  }
+}
+
+/**
+ * Call a user-provided synchronous hook function.
+ *
+ * @param {String} type
+ */
+
+p.callHook = function (type) {
+  if (this.hooks && this.hooks[type]) {
+    this.hooks[type].call(this.vm, this.el)
+  }
+}
+
+/**
+ * Call a user-provided, potentially-async hook function.
+ * We check for the length of arguments to see if the hook
+ * expects a `done` callback. If true, the transition's end
+ * will be determined by when the user calls that callback;
+ * otherwise, the end is determined by the CSS transition or
+ * animation.
+ *
+ * @param {String} type
+ */
+
+p.callHookWithCb = function (type) {
+  var hook = this.hooks && this.hooks[type]
+  if (hook) {
+    if (hook.length > 1) {
+      this.pendingJsCb = _.cancellable(this[type + 'Done'])
+    }
+    hook.call(this.vm, this.el, this.pendingJsCb)
+  }
+}
+
+/**
+ * Get an element's transition type based on the
+ * calculated styles.
+ *
+ * @param {String} className
+ * @return {Number}
+ */
+
+p.getCssTransitionType = function (className) {
+  /* istanbul ignore if */
+  if (
+    !transitionEndEvent ||
+    // skip CSS transitions if page is not visible -
+    // this solves the issue of transitionend events not
+    // firing until the page is visible again.
+    // pageVisibility API is supported in IE10+, same as
+    // CSS transitions.
+    document.hidden ||
+    // explicit js-only transition
+    (this.hooks && this.hooks.css === false)
+  ) {
+    return
+  }
+  var type = this.typeCache[className]
+  if (type) return type
+  var inlineStyles = this.el.style
+  var computedStyles = window.getComputedStyle(this.el)
+  var transDuration =
+    inlineStyles[transDurationProp] ||
+    computedStyles[transDurationProp]
+  if (transDuration && transDuration !== '0s') {
+    type = TYPE_TRANSITION
+  } else {
+    var animDuration =
+      inlineStyles[animDurationProp] ||
+      computedStyles[animDurationProp]
+    if (animDuration && animDuration !== '0s') {
+      type = TYPE_ANIMATION
+    }
+  }
+  if (type) {
+    this.typeCache[className] = type
+  }
+  return type
+}
+
+/**
+ * Setup a CSS transitionend/animationend callback.
+ *
+ * @param {String} event
+ * @param {Function} cb
+ */
+
+p.setupCssCb = function (event, cb) {
+  this.pendingCssEvent = event
+  var self = this
+  var el = this.el
+  var onEnd = this.pendingCssCb = function (e) {
+    if (e.target === el) {
+      _.off(el, event, onEnd)
+      self.pendingCssEvent = self.pendingCssCb = null
+      if (!self.pendingJsCb && cb) {
+        cb()
+      }
+    }
+  }
+  _.on(el, event, onEnd)
+}
+
+module.exports = Transition