RubyGems - statixite - Versions diffs - 1.0.0 - Mend

statixite 1.0.0

Files changed (462) hide show

data/vendor/assets/bower_components/vue/src/compiler/index.js ADDED Viewed

@@ -0,0 +1,4 @@
+var _ = require('../util')
+_.extend(exports, require('./compile'))
+_.extend(exports, require('./transclude'))

data/vendor/assets/bower_components/vue/src/compiler/transclude.js ADDED Viewed

@@ -0,0 +1,144 @@
+var _ = require('../util')
+var config = require('../config')
+var templateParser = require('../parsers/template')
+/**
+ * Process an element or a DocumentFragment based on a
+ * instance option object. This allows us to transclude
+ * a template node/fragment before the instance is created,
+ * so the processed fragment can then be cloned and reused
+ * in v-repeat.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Element|DocumentFragment}
+ */
+exports.transclude = function (el, options) {
+  // extract container attributes to pass them down
+  // to compiler, because they need to be compiled in
+  // parent scope. we are mutating the options object here
+  // assuming the same object will be used for compile
+  // right after this.
+  if (options) {
+    options._containerAttrs = extractAttrs(el)
+  }
+  // for template tags, what we want is its content as
+  // a documentFragment (for fragment instances)
+  if (_.isTemplate(el)) {
+    el = templateParser.parse(el)
+  }
+  if (options) {
+    if (options._asComponent && !options.template) {
+      options.template = '<content></content>'
+    }
+    if (options.template) {
+      options._content = _.extractContent(el)
+      el = transcludeTemplate(el, options)
+    }
+  }
+  if (el instanceof DocumentFragment) {
+    // anchors for fragment instance
+    // passing in `persist: true` to avoid them being
+    // discarded by IE during template cloning
+    _.prepend(_.createAnchor('v-start', true), el)
+    el.appendChild(_.createAnchor('v-end', true))
+  }
+  return el
+}
+/**
+ * Process the template option.
+ * If the replace option is true this will swap the $el.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Element|DocumentFragment}
+ */
+function transcludeTemplate (el, options) {
+  var template = options.template
+  var frag = templateParser.parse(template, true)
+  if (frag) {
+    var replacer = frag.firstChild
+    var tag = replacer.tagName && replacer.tagName.toLowerCase()
+    if (options.replace) {
+      /* istanbul ignore if */
+      if (el === document.body) {
+        process.env.NODE_ENV !== 'production' && _.warn(
+          'You are mounting an instance with a template to ' +
+          '<body>. This will replace <body> entirely. You ' +
+          'should probably use `replace: false` here.'
+        )
+      }
+      // there are many cases where the instance must
+      // become a fragment instance: basically anything that
+      // can create more than 1 root nodes.
+      if (
+        // multi-children template
+        frag.childNodes.length > 1 ||
+        // non-element template
+        replacer.nodeType !== 1 ||
+        // single nested component
+        tag === 'component' ||
+        _.resolveAsset(options, 'components', tag) ||
+        replacer.hasAttribute(config.prefix + 'component') ||
+        // element directive
+        _.resolveAsset(options, 'elementDirectives', tag) ||
+        // repeat block
+        replacer.hasAttribute(config.prefix + 'repeat')
+      ) {
+        return frag
+      } else {
+        options._replacerAttrs = extractAttrs(replacer)
+        mergeAttrs(el, replacer)
+        return replacer
+      }
+    } else {
+      el.appendChild(frag)
+      return el
+    }
+  } else {
+    process.env.NODE_ENV !== 'production' && _.warn(
+      'Invalid template option: ' + template
+    )
+  }
+}
+/**
+ * Helper to extract a component container's attributes
+ * into a plain object array.
+ *
+ * @param {Element} el
+ * @return {Array}
+ */
+function extractAttrs (el) {
+  if (el.nodeType === 1 && el.hasAttributes()) {
+    return _.toArray(el.attributes)
+  }
+}
+/**
+ * Merge the attributes of two elements, and make sure
+ * the class names are merged properly.
+ *
+ * @param {Element} from
+ * @param {Element} to
+ */
+function mergeAttrs (from, to) {
+  var attrs = from.attributes
+  var i = attrs.length
+  var name, value
+  while (i--) {
+    name = attrs[i].name
+    value = attrs[i].value
+    if (!to.hasAttribute(name)) {
+      to.setAttribute(name, value)
+    } else if (name === 'class') {
+      value = to.getAttribute(name) + ' ' + value
+      to.setAttribute(name, value)
+    }
+  }
+}

data/vendor/assets/bower_components/vue/src/config.js ADDED Viewed

@@ -0,0 +1,124 @@
+module.exports = {
+  /**
+   * The prefix to look for when parsing directives.
+   *
+   * @type {String}
+   */
+  prefix: 'v-',
+  /**
+   * Whether to print debug messages.
+   * Also enables stack trace for warnings.
+   *
+   * @type {Boolean}
+   */
+  debug: false,
+  /**
+   * Strict mode.
+   * Disables asset lookup in the view parent chain.
+   */
+  strict: false,
+  /**
+   * Whether to suppress warnings.
+   *
+   * @type {Boolean}
+   */
+  silent: false,
+  /**
+   * Whether allow observer to alter data objects'
+   * __proto__.
+   *
+   * @type {Boolean}
+   */
+  proto: true,
+  /**
+   * Whether to parse mustache tags in templates.
+   *
+   * @type {Boolean}
+   */
+  interpolate: true,
+  /**
+   * Whether to use async rendering.
+   */
+  async: true,
+  /**
+   * Whether to warn against errors caught when evaluating
+   * expressions.
+   */
+  warnExpressionErrors: true,
+  /**
+   * Internal flag to indicate the delimiters have been
+   * changed.
+   *
+   * @type {Boolean}
+   */
+  _delimitersChanged: true,
+  /**
+   * List of asset types that a component can own.
+   *
+   * @type {Array}
+   */
+  _assetTypes: [
+    'component',
+    'directive',
+    'elementDirective',
+    'filter',
+    'transition',
+    'partial'
+  ],
+  /**
+   * prop binding modes
+   */
+  _propBindingModes: {
+    ONE_WAY: 0,
+    TWO_WAY: 1,
+    ONE_TIME: 2
+  },
+  /**
+   * Max circular updates allowed in a batcher flush cycle.
+   */
+  _maxUpdateCount: 100
+}
+/**
+ * Interpolation delimiters.
+ * We need to mark the changed flag so that the text parser
+ * knows it needs to recompile the regex.
+ *
+ * @type {Array<String>}
+ */
+var delimiters = ['{{', '}}']
+Object.defineProperty(module.exports, 'delimiters', {
+  get: function () {
+    return delimiters
+  },
+  set: function (val) {
+    delimiters = val
+    this._delimitersChanged = true
+  }
+})

data/vendor/assets/bower_components/vue/src/directive.js ADDED Viewed

@@ -0,0 +1,254 @@
+var _ = require('./util')
+var config = require('./config')
+var Watcher = require('./watcher')
+var textParser = require('./parsers/text')
+var expParser = require('./parsers/expression')
+function noop () {}
+/**
+ * A directive links a DOM element with a piece of data,
+ * which is the result of evaluating an expression.
+ * It registers a watcher with the expression and calls
+ * the DOM update function when a change is triggered.
+ *
+ * @param {String} name
+ * @param {Node} el
+ * @param {Vue} vm
+ * @param {Object} descriptor
+ *                 - {String} expression
+ *                 - {String} [arg]
+ *                 - {Array<Object>} [filters]
+ * @param {Object} def - directive definition object
+ * @param {Vue|undefined} host - transclusion host target
+ * @constructor
+ */
+function Directive (name, el, vm, descriptor, def, host) {
+  // public
+  this.name = name
+  this.el = el
+  this.vm = vm
+  // copy descriptor props
+  this.raw = descriptor.raw
+  this.expression = descriptor.expression
+  this.arg = descriptor.arg
+  this.filters = descriptor.filters
+  // private
+  this._descriptor = descriptor
+  this._host = host
+  this._locked = false
+  this._bound = false
+  this._listeners = null
+  // init
+  this._bind(def)
+}
+/**
+ * Initialize the directive, mixin definition properties,
+ * setup the watcher, call definition bind() and update()
+ * if present.
+ *
+ * @param {Object} def
+ */
+Directive.prototype._bind = function (def) {
+  if (
+    (this.name !== 'cloak' || this.vm._isCompiled) &&
+    this.el && this.el.removeAttribute
+  ) {
+    this.el.removeAttribute(config.prefix + this.name)
+  }
+  if (typeof def === 'function') {
+    this.update = def
+  } else {
+    _.extend(this, def)
+  }
+  this._watcherExp = this.expression
+  this._checkDynamicLiteral()
+  if (this.bind) {
+    this.bind()
+  }
+  if (this._watcherExp &&
+      (this.update || this.twoWay) &&
+      (!this.isLiteral || this._isDynamicLiteral) &&
+      !this._checkStatement()) {
+    // wrapped updater for context
+    var dir = this
+    if (this.update) {
+      this._update = function (val, oldVal) {
+        if (!dir._locked) {
+          dir.update(val, oldVal)
+        }
+      }
+    } else {
+      this._update = noop
+    }
+    // pre-process hook called before the value is piped
+    // through the filters. used in v-repeat.
+    var preProcess = this._preProcess
+      ? _.bind(this._preProcess, this)
+      : null
+    var watcher = this._watcher = new Watcher(
+      this.vm,
+      this._watcherExp,
+      this._update, // callback
+      {
+        filters: this.filters,
+        twoWay: this.twoWay,
+        deep: this.deep,
+        preProcess: preProcess
+      }
+    )
+    if (this._initValue != null) {
+      watcher.set(this._initValue)
+    } else if (this.update) {
+      this.update(watcher.value)
+    }
+  }
+  this._bound = true
+}
+/**
+ * check if this is a dynamic literal binding.
+ *
+ * e.g. v-component="{{currentView}}"
+ */
+Directive.prototype._checkDynamicLiteral = function () {
+  var expression = this.expression
+  if (expression && this.isLiteral) {
+    var tokens = textParser.parse(expression)
+    if (tokens) {
+      var exp = textParser.tokensToExp(tokens)
+      this.expression = this.vm.$get(exp)
+      this._watcherExp = exp
+      this._isDynamicLiteral = true
+    }
+  }
+}
+/**
+ * Check if the directive is a function caller
+ * and if the expression is a callable one. If both true,
+ * we wrap up the expression and use it as the event
+ * handler.
+ *
+ * e.g. v-on="click: a++"
+ *
+ * @return {Boolean}
+ */
+Directive.prototype._checkStatement = function () {
+  var expression = this.expression
+  if (
+    expression && this.acceptStatement &&
+    !expParser.isSimplePath(expression)
+  ) {
+    var fn = expParser.parse(expression).get
+    var vm = this.vm
+    var handler = function () {
+      fn.call(vm, vm)
+    }
+    if (this.filters) {
+      handler = vm._applyFilters(handler, null, this.filters)
+    }
+    this.update(handler)
+    return true
+  }
+}
+/**
+ * Check for an attribute directive param, e.g. lazy
+ *
+ * @param {String} name
+ * @return {String}
+ */
+Directive.prototype._checkParam = function (name) {
+  var param = this.el.getAttribute(name)
+  if (param !== null) {
+    this.el.removeAttribute(name)
+    param = this.vm.$interpolate(param)
+  }
+  return param
+}
+/**
+ * Set the corresponding value with the setter.
+ * This should only be used in two-way directives
+ * e.g. v-model.
+ *
+ * @param {*} value
+ * @public
+ */
+Directive.prototype.set = function (value) {
+  /* istanbul ignore else */
+  if (this.twoWay) {
+    this._withLock(function () {
+      this._watcher.set(value)
+    })
+  } else if (process.env.NODE_ENV !== 'production') {
+    _.warn(
+      'Directive.set() can only be used inside twoWay' +
+      'directives.'
+    )
+  }
+}
+/**
+ * Execute a function while preventing that function from
+ * triggering updates on this directive instance.
+ *
+ * @param {Function} fn
+ */
+Directive.prototype._withLock = function (fn) {
+  var self = this
+  self._locked = true
+  fn.call(self)
+  _.nextTick(function () {
+    self._locked = false
+  })
+}
+/**
+ * Convenience method that attaches a DOM event listener
+ * to the directive element and autometically tears it down
+ * during unbind.
+ *
+ * @param {String} event
+ * @param {Function} handler
+ */
+Directive.prototype.on = function (event, handler) {
+  _.on(this.el, event, handler)
+  ;(this._listeners || (this._listeners = []))
+    .push([event, handler])
+}
+/**
+ * Teardown the watcher and call unbind.
+ */
+Directive.prototype._teardown = function () {
+  if (this._bound) {
+    this._bound = false
+    if (this.unbind) {
+      this.unbind()
+    }
+    if (this._watcher) {
+      this._watcher.teardown()
+    }
+    var listeners = this._listeners
+    if (listeners) {
+      for (var i = 0; i < listeners.length; i++) {
+        _.off(this.el, listeners[i][0], listeners[i][1])
+      }
+    }
+    this.vm = this.el =
+    this._watcher = this._listeners = null
+  }
+}
+module.exports = Directive