vapid 0.1.0

data/lib/vapid/vendor/trix/polyfills/vendor/README.md

@@ -0,0 +1,2 @@
+* [CustomElements.js](https://github.com/webcomponents/webcomponentsjs/releases)
+* [promise.js](https://github.com/taylorhakes/promise-polyfill)

data/lib/vapid/vendor/trix/polyfills/vendor/promise.js

@@ -0,0 +1,228 @@
+(function (root) {
+
+  // Store setTimeout reference so promise-polyfill will be unaffected by
+  // other code modifying setTimeout (like sinon.useFakeTimers())
+  var setTimeoutFunc = setTimeout;
+
+  function noop() {
+  }
+
+  // Use polyfill for setImmediate for performance gains
+  var asap = (typeof setImmediate === 'function' && setImmediate) ||
+    function (fn) {
+      setTimeoutFunc(fn, 1);
+    };
+
+  var onUnhandledRejection = function onUnhandledRejection(err) {
+    if (typeof console !== 'undefined' && console) {
+      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console
+    }
+  };
+
+  // Polyfill for Function.prototype.bind
+  function bind(fn, thisArg) {
+    return function () {
+      fn.apply(thisArg, arguments);
+    };
+  }
+
+  function Promise(fn) {
+    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');
+    if (typeof fn !== 'function') throw new TypeError('not a function');
+    this._state = 0;
+    this._handled = false;
+    this._value = undefined;
+    this._deferreds = [];
+
+    doResolve(fn, this);
+  }
+
+  function handle(self, deferred) {
+    while (self._state === 3) {
+      self = self._value;
+    }
+    if (self._state === 0) {
+      self._deferreds.push(deferred);
+      return;
+    }
+    self._handled = true;
+    asap(function () {
+      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;
+      if (cb === null) {
+        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);
+        return;
+      }
+      var ret;
+      try {
+        ret = cb(self._value);
+      } catch (e) {
+        reject(deferred.promise, e);
+        return;
+      }
+      resolve(deferred.promise, ret);
+    });
+  }
+
+  function resolve(self, newValue) {
+    try {
+      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure
+      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');
+      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
+        var then = newValue.then;
+        if (newValue instanceof Promise) {
+          self._state = 3;
+          self._value = newValue;
+          finale(self);
+          return;
+        } else if (typeof then === 'function') {
+          doResolve(bind(then, newValue), self);
+          return;
+        }
+      }
+      self._state = 1;
+      self._value = newValue;
+      finale(self);
+    } catch (e) {
+      reject(self, e);
+    }
+  }
+
+  function reject(self, newValue) {
+    self._state = 2;
+    self._value = newValue;
+    finale(self);
+  }
+
+  function finale(self) {
+    if (self._state === 2 && self._deferreds.length === 0) {
+      setTimeout(function() {
+        if (!self._handled) {
+          onUnhandledRejection(self._value);
+        }
+      }, 1);
+    }
+    
+    for (var i = 0, len = self._deferreds.length; i < len; i++) {
+      handle(self, self._deferreds[i]);
+    }
+    self._deferreds = null;
+  }
+
+  function Handler(onFulfilled, onRejected, promise) {
+    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
+    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
+    this.promise = promise;
+  }
+
+  /**
+   * Take a potentially misbehaving resolver function and make sure
+   * onFulfilled and onRejected are only called once.
+   *
+   * Makes no guarantees about asynchrony.
+   */
+  function doResolve(fn, self) {
+    var done = false;
+    try {
+      fn(function (value) {
+        if (done) return;
+        done = true;
+        resolve(self, value);
+      }, function (reason) {
+        if (done) return;
+        done = true;
+        reject(self, reason);
+      });
+    } catch (ex) {
+      if (done) return;
+      done = true;
+      reject(self, ex);
+    }
+  }
+
+  Promise.prototype['catch'] = function (onRejected) {
+    return this.then(null, onRejected);
+  };
+
+  Promise.prototype.then = function (onFulfilled, onRejected) {
+    var prom = new Promise(noop);
+    handle(this, new Handler(onFulfilled, onRejected, prom));
+    return prom;
+  };
+
+  Promise.all = function (arr) {
+    var args = Array.prototype.slice.call(arr);
+
+    return new Promise(function (resolve, reject) {
+      if (args.length === 0) return resolve([]);
+      var remaining = args.length;
+
+      function res(i, val) {
+        try {
+          if (val && (typeof val === 'object' || typeof val === 'function')) {
+            var then = val.then;
+            if (typeof then === 'function') {
+              then.call(val, function (val) {
+                res(i, val);
+              }, reject);
+              return;
+            }
+          }
+          args[i] = val;
+          if (--remaining === 0) {
+            resolve(args);
+          }
+        } catch (ex) {
+          reject(ex);
+        }
+      }
+
+      for (var i = 0; i < args.length; i++) {
+        res(i, args[i]);
+      }
+    });
+  };
+
+  Promise.resolve = function (value) {
+    if (value && typeof value === 'object' && value.constructor === Promise) {
+      return value;
+    }
+
+    return new Promise(function (resolve) {
+      resolve(value);
+    });
+  };
+
+  Promise.reject = function (value) {
+    return new Promise(function (resolve, reject) {
+      reject(value);
+    });
+  };
+
+  Promise.race = function (values) {
+    return new Promise(function (resolve, reject) {
+      for (var i = 0, len = values.length; i < len; i++) {
+        values[i].then(resolve, reject);
+      }
+    });
+  };
+
+  /**
+   * Set the immediate function to execute callbacks
+   * @param fn {function} Function to execute
+   * @private
+   */
+  Promise._setImmediateFn = function _setImmediateFn(fn) {
+    asap = fn;
+  };
+  
+  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {
+    onUnhandledRejection = fn;
+  };
+
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = Promise;
+  } else if (!root.Promise) {
+    root.Promise = Promise;
+  }
+
+})(this);

data/lib/vapid/vendor/trix/src/trix/VERSION

@@ -0,0 +1 @@
+0.10.1

data/lib/vapid/vendor/trix/src/trix/config/block_attributes.coffee

@@ -0,0 +1,37 @@
+Trix.config.blockAttributes = attributes =
+  default:
+    tagName: "div"
+    parse: false
+  quote:
+    tagName: "blockquote"
+    nestable: true
+  heading1:
+    tagName: "h1"
+    terminal: true
+    breakOnReturn: true
+    group: false
+  code:
+    tagName: "pre"
+    terminal: true
+    text:
+      plaintext: true
+  bulletList:
+    tagName: "ul"
+    parse: false
+  bullet:
+    tagName: "li"
+    listAttribute: "bulletList"
+    group: false
+    nestable: true
+    test: (element) ->
+      Trix.tagName(element.parentNode) is attributes[@listAttribute].tagName
+  numberList:
+    tagName: "ol"
+    parse: false
+  number:
+    tagName: "li"
+    listAttribute: "numberList"
+    group: false
+    nestable: true
+    test: (element) ->
+      Trix.tagName(element.parentNode) is attributes[@listAttribute].tagName

data/lib/vapid/vendor/trix/src/trix/config/css.coffee

@@ -0,0 +1,12 @@
+Trix.config.css =
+  classNames:
+    attachment:
+      container: "attachment"
+      typePrefix: "attachment-"
+      caption: "caption"
+      captionEdited: "caption-edited"
+      captionEditor: "caption-editor"
+      editingCaption: "caption-editing"
+      progressBar: "progress"
+      removeButton: "remove icon"
+      size: "size"

data/lib/vapid/vendor/trix/src/trix/config/file_size_formatting.coffee

@@ -0,0 +1,22 @@
+#= require trix/config/lang
+
+{lang} = Trix.config
+sizes = [lang.bytes, lang.KB, lang.MB, lang.GB, lang.TB, lang.PB]
+
+Trix.config.fileSize =
+  prefix: "IEC"
+  precision: 2
+
+  formatter: (number) ->
+    switch number
+      when 0 then "0 #{lang.bytes}"
+      when 1 then "1 #{lang.byte}"
+      else
+        base = switch @prefix
+          when "SI"  then 1000
+          when "IEC" then 1024
+        exp = Math.floor(Math.log(number) / Math.log(base))
+        humanSize = number / Math.pow(base, exp)
+        string = humanSize.toFixed(@precision)
+        withoutInsignificantZeros = string.replace(/0*$/, "").replace(/\.$/, "")
+        "#{withoutInsignificantZeros} #{sizes[exp]}"

data/lib/vapid/vendor/trix/src/trix/config/index.coffee

@@ -0,0 +1,9 @@
+#= require trix/config/lang
+#= require trix/config/css
+#= require trix/config/block_attributes
+#= require trix/config/file_size_formatting
+#= require trix/config/text_attributes
+#= require trix/config/serialization
+#= require trix/config/toolbar
+#= require trix/config/undo_interval
+#= require trix/config/selection_elements

data/lib/vapid/vendor/trix/src/trix/config/lang.coffee

@@ -0,0 +1,26 @@
+Trix.config.lang =
+  bold: "Bold"
+  bullets: "Bullets"
+  byte:  "Byte"
+  bytes: "Bytes"
+  captionPlaceholder: "Type a caption here…"
+  captionPrompt: "Add a caption…"
+  code: "Code"
+  heading1: "Heading"
+  indent: "Increase Level"
+  italic: "Italic"
+  link: "Link"
+  numbers: "Numbers"
+  outdent: "Decrease Level"
+  quote: "Quote"
+  redo: "Redo"
+  remove: "Remove"
+  strike: "Strikethrough"
+  undo: "Undo"
+  unlink: "Unlink"
+  urlPlaceholder: "Enter a URL…"
+  GB: "GB"
+  KB: "KB"
+  MB: "MB"
+  PB: "PB"
+  TB: "TB"

data/lib/vapid/vendor/trix/src/trix/config/selection_elements.coffee

@@ -0,0 +1,26 @@
+{makeElement} = Trix
+
+prototypes =
+  cursorTarget:
+    makeElement
+      tagName: "span"
+      textContent: Trix.ZERO_WIDTH_SPACE
+      data:
+        trixSelection: true
+        trixCursorTarget: true
+        trixSerialize: false
+
+Trix.extend
+  selectionElements:
+    selector: "[data-trix-selection]"
+
+    cssText: """
+      font-size: 0 !important;
+      padding: 0 !important;
+      margin: 0 !important;
+      border: none !important;
+      line-height: 0 !important;
+    """
+
+    create: (name) ->
+      prototypes[name].cloneNode(true)

data/lib/vapid/vendor/trix/src/trix/config/serialization.coffee

@@ -0,0 +1,63 @@
+unserializableElementSelector = "[data-trix-serialize=false]"
+unserializableAttributeNames = ["contenteditable", "data-trix-id", "data-trix-store-key", "data-trix-mutable"]
+serializedAttributesAttribute = "data-trix-serialized-attributes"
+serializedAttributesSelector = "[#{serializedAttributesAttribute}]"
+
+blockCommentPattern = new RegExp("<!--block-->", "g")
+
+Trix.extend
+  serializers:
+    "application/json": (serializable) ->
+      if serializable instanceof Trix.Document
+        document = serializable
+      else if serializable instanceof HTMLElement
+        document = Trix.Document.fromHTML(serializable.innerHTML)
+      else
+        throw new Error "unserializable object"
+
+      document.toSerializableDocument().toJSONString()
+
+    "text/html": (serializable) ->
+      if serializable instanceof Trix.Document
+        element = Trix.DocumentView.render(serializable)
+      else if serializable instanceof HTMLElement
+        element = serializable.cloneNode(true)
+      else
+        throw new Error "unserializable object"
+
+      # Remove unserializable elements
+      for el in element.querySelectorAll(unserializableElementSelector)
+        el.parentNode.removeChild(el)
+
+      # Remove unserializable attributes
+      for attribute in unserializableAttributeNames
+        for el in element.querySelectorAll("[#{attribute}]")
+          el.removeAttribute(attribute)
+
+      # Rewrite elements with serialized attribute overrides
+      for el in element.querySelectorAll(serializedAttributesSelector) then try
+        attributes = JSON.parse(el.getAttribute(serializedAttributesAttribute))
+        el.removeAttribute(serializedAttributesAttribute)
+        for name, value of attributes
+          el.setAttribute(name, value)
+
+      element.innerHTML.replace(blockCommentPattern, "")
+
+  deserializers:
+    "application/json": (string) ->
+      Trix.Document.fromJSONString(string)
+
+    "text/html": (string) ->
+      Trix.Document.fromHTML(string)
+
+  serializeToContentType: (serializable, contentType) ->
+    if serializer = Trix.serializers[contentType]
+      serializer(serializable)
+    else
+      throw new Error "unknown content type: #{contentType}"
+
+  deserializeFromContentType: (string, contentType) ->
+    if deserializer = Trix.deserializers[contentType]
+      deserializer(string)
+    else
+      throw new Error "unknown content type: #{contentType}"

data/lib/vapid/vendor/trix/src/trix/config/text_attributes.coffee

@@ -0,0 +1,25 @@
+Trix.config.textAttributes =
+  bold:
+    tagName: "strong"
+    inheritable: true
+    parser: (element) ->
+      style = window.getComputedStyle(element)
+      style["fontWeight"] is "bold" or style["fontWeight"] >= 600
+  italic:
+    tagName: "em"
+    inheritable: true
+    parser: (element) ->
+      style = window.getComputedStyle(element)
+      style["fontStyle"] is "italic"
+  href:
+    groupTagName: "a"
+    parser: (element) ->
+      {attachmentSelector} = Trix.AttachmentView
+      matchingSelector = "a:not(#{attachmentSelector})"
+      if link = Trix.findClosestElementFromNode(element, {matchingSelector})
+        link.getAttribute("href")
+  strike:
+    tagName: "del"
+    inheritable: true
+  frozen:
+    style: { "backgroundColor": "highlight" }