fixed bower & added dependencies & cleanup

Examples/bower_components/y-text/y-text.es6

@@ -0,0 +1,462 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+/* global Y, Element */
+'use strict'
+
+function extend (Y) {
+  Y.requestModules(['Array']).then(function () {
+    class YText extends Y.Array['class'] {
+      constructor (os, _model, _content) {
+        super(os, _model, _content)
+        this.textfields = []
+        this.aceInstances = []
+      }
+      _destroy () {
+        this.unbindAll()
+        this.textfields = null
+        this.aceInstances = null
+        super._destroy()
+      }
+      toString () {
+        return this._content.map(function (c) {
+          return c.val
+        }).join('')
+      }
+      insert (pos, content) {
+        super.insert(pos, content.split(''))
+      }
+      unbindAll () {
+        for (let i = this.textfields.length - 1; i >= 0; i--) {
+          this.unbindTextarea(this.textfields[i].editor)
+        }
+        for (let i = this.aceInstances.length - 1; i >= 0; i--) {
+          this.unbindAce(this.aceInstances[i].editor)
+        }
+      }
+      unbindAce (ace) {
+        var i = this.aceInstances.findIndex(function (binding) {
+          return binding.editor === ace
+        })
+        if (i >= 0) {
+          var binding = this.aceInstances[i]
+          this.unobserve(binding.yCallback)
+          binding.editor.off('change', binding.aceCallback)
+          this.aceInstances.splice(i, 1)
+        }
+      }
+      bindAce (ace, options) {
+        var self = this
+
+        // this function makes sure that either the
+        // ace event is executed, or the yjs observer is executed
+        var token = true
+        function mutualExcluse (f) {
+          if (token) {
+            token = false
+            try {
+              f()
+            } catch (e) {
+              token = true
+              throw new Error(e)
+            }
+            token = true
+          }
+        }
+        ace.markers = []
+        var disableMarkers = false
+
+        if (typeof options === 'object') {
+          if (typeof options.disableMarkers !== 'undefined') {
+            disableMarkers = options.disableMarkers
+          }
+        }
+
+        ace.setValue(this.toString())
+
+        function aceCallback (delta) {
+          mutualExcluse(function () {
+            var start = 0
+            var length = 0
+
+            var aceDocument = ace.getSession().getDocument()
+            if (delta.action === 'insert') {
+              start = aceDocument.positionToIndex(delta.start, 0)
+              self.insert(start, delta.lines.join('\n'))
+            } else if (delta.action === 'remove') {
+              start = aceDocument.positionToIndex(delta.start, 0)
+              length = delta.lines.join('\n').length
+              self.delete(start, length)
+            }
+          })
+        }
+        ace.on('change', aceCallback)
+
+        if (!disableMarkers) {
+          if (this.inteval) {
+            clearInterval(this.inteval)
+          }
+          this.inteval = setInterval(function () {
+            var i = 0
+            var now = Date.now()
+            var timeVisible = 800
+
+            while (i < ace.markers.length) {
+              var marker = ace.markers[i]
+
+              if (marker.timestamp + timeVisible < now) {
+                ace.getSession().removeMarker(marker.id)
+                ace.markers.splice(i, 1)
+                i--
+              }
+              i++
+            }
+          }, 1000)
+        }
+        var Range = window.ace.require('ace/range').Range
+        function setMarker (start, end, klazz) {
+          if (disableMarkers) {
+            return
+          }
+          var offset = 0
+          if (start.row === end.row && start.column === end.column) {
+            offset = 1
+          }
+          var range = new Range(start.row, start.column, end.row, end.column + offset)
+          var marker = ace.session.addMarker(range, klazz, 'text')
+          ace.markers.push({id: marker, timestamp: Date.now()})
+        }
+
+        function yCallback (events) {
+          var aceDocument = ace.getSession().getDocument()
+          mutualExcluse(function () {
+            for (var i = 0; i < events.length; i++) {
+              var event = events[i]
+              if (event.type === 'insert') {
+                let start = aceDocument.indexToPosition(event.index, 0)
+                let end = aceDocument.indexToPosition(event.index + event.value.length, 0)
+                aceDocument.insert(start, event.value)
+
+                setMarker(start, end, 'inserted')
+              } else if (event.type === 'delete') {
+                let start = aceDocument.indexToPosition(event.index, 0)
+                let end = aceDocument.indexToPosition(event.index + event.length, 0)
+                var range = new Range(start.row, start.column, end.row, end.column)
+                aceDocument.remove(range)
+
+                setMarker(start, end, 'deleted')
+              }
+            }
+          })
+        }
+        this.observe(yCallback)
+        this.aceInstances.push({
+          editor: ace,
+          yCallback: yCallback,
+          aceCallback: aceCallback
+        })
+      }
+      bind () {
+        var e = arguments[0]
+        if (e instanceof Element) {
+          this.bindTextarea.apply(this, arguments)
+        } else if (e != null && e.session != null && e.getSession != null && e.setValue != null) {
+          this.bindAce.apply(this, arguments)
+        } else {
+          console.error('Cannot bind, unsupported editor!')
+        }
+      }
+      unbindTextarea (textarea) {
+        var i = this.textfields.findIndex(function (binding) {
+          return binding.editor === textarea
+        })
+        if (i >= 0) {
+          var binding = this.textfields[i]
+          this.unobserve(binding.yCallback)
+          var e = binding.editor
+          e.onkeydown = null
+          e.onkeyup = null
+          e.onkeypress = null
+          e.onpaste = null
+          e.oncut = null
+          this.textfields.splice(i, 1)
+        }
+      }
+      bindTextarea (textfield, domRoot) {
+        domRoot = domRoot || window; // eslint-disable-line
+        if (domRoot.getSelection == null) {
+          domRoot = window; // eslint-disable-line
+        }
+
+        // don't duplicate!
+        for (var t = 0; t < this.textfields.length; t++) {
+          if (this.textfields[t].editor === textfield) {
+            return
+          }
+        }
+        var creatorToken = false
+
+        var word = this
+        textfield.value = this.toString()
+
+        var createRange, writeRange, writeContent
+        if (textfield.selectionStart != null && textfield.setSelectionRange != null) {
+          createRange = function (fix) {
+            var left = textfield.selectionStart
+            var right = textfield.selectionEnd
+            if (fix != null) {
+              left = fix(left)
+              right = fix(right)
+            }
+            return {
+              left: left,
+              right: right
+            }
+          }
+          writeRange = function (range) {
+            writeContent(word.toString())
+            textfield.setSelectionRange(range.left, range.right)
+          }
+          writeContent = function (content) {
+            textfield.value = content
+          }
+        } else {
+          createRange = function (fix) {
+            var range = {}
+            var s = domRoot.getSelection()
+            var clength = textfield.textContent.length
+            range.left = Math.min(s.anchorOffset, clength)
+            range.right = Math.min(s.focusOffset, clength)
+            if (fix != null) {
+              range.left = fix(range.left)
+              range.right = fix(range.right)
+            }
+            var editedElement = s.focusNode
+            if (editedElement === textfield || editedElement === textfield.childNodes[0]) {
+              range.isReal = true
+            } else {
+              range.isReal = false
+            }
+            return range
+          }
+
+          writeRange = function (range) {
+            writeContent(word.toString())
+            var textnode = textfield.childNodes[0]
+            if (range.isReal && textnode != null) {
+              if (range.left < 0) {
+                range.left = 0
+              }
+              range.right = Math.max(range.left, range.right)
+              if (range.right > textnode.length) {
+                range.right = textnode.length
+              }
+              range.left = Math.min(range.left, range.right)
+              var r = document.createRange(); // eslint-disable-line
+              r.setStart(textnode, range.left)
+              r.setEnd(textnode, range.right)
+              var s = window.getSelection(); // eslint-disable-line
+              s.removeAllRanges()
+              s.addRange(r)
+            }
+          }
+          writeContent = function (content) {
+            var contentArray = content.replace(new RegExp('\n', 'g'), ' ').split(' '); // eslint-disable-line
+            textfield.innerText = ''
+            for (var i = 0; i < contentArray.length; i++) {
+              var c = contentArray[i]
+              textfield.innerText += c
+              if (i !== contentArray.length - 1) {
+                textfield.innerHTML += '&nbsp;'
+              }
+            }
+          }
+        }
+        writeContent(this.toString())
+
+        function yCallback (events) {
+          for (var e = 0; e < events.length; e++) {
+            var event = events[e]
+            if (!creatorToken) {
+              var oPos, fix
+              if (event.type === 'insert') {
+                oPos = event.index
+                fix = function (cursor) { // eslint-disable-line
+                  if (cursor <= oPos) {
+                    return cursor
+                  } else {
+                    cursor += 1
+                    return cursor
+                  }
+                }
+                var r = createRange(fix)
+                writeRange(r)
+              } else if (event.type === 'delete') {
+                oPos = event.index
+                fix = function (cursor) { // eslint-disable-line
+                  if (cursor < oPos) {
+                    return cursor
+                  } else {
+                    cursor -= 1
+                    return cursor
+                  }
+                }
+                r = createRange(fix)
+                writeRange(r)
+              }
+            }
+          }
+        }
+        this.observe(yCallback)
+        // consume all text-insert changes.
+        textfield.onkeypress = function (event) {
+          if (word.is_deleted) {
+            // if word is deleted, do not do anything ever again
+            textfield.onkeypress = null
+            return true
+          }
+          creatorToken = true
+          var char
+          if (event.keyCode === 13) {
+            char = '\n'
+          } else if (event.key != null) {
+            if (event.charCode === 32) {
+              char = ' '
+            } else {
+              char = event.key
+            }
+          } else {
+            char = window.String.fromCharCode(event.keyCode); // eslint-disable-line
+          }
+          if (char.length > 1) {
+            return true
+          } else if (char.length > 0) {
+            var r = createRange()
+            var pos = Math.min(r.left, r.right, word.length)
+            var diff = Math.abs(r.right - r.left)
+            word.delete(pos, diff)
+            word.insert(pos, char)
+            r.left = pos + char.length
+            r.right = r.left
+            writeRange(r)
+          }
+          event.preventDefault()
+          creatorToken = false
+          return false
+        }
+        textfield.onpaste = function (event) {
+          if (word.is_deleted) {
+            // if word is deleted, do not do anything ever again
+            textfield.onpaste = null
+            return true
+          }
+          event.preventDefault()
+        }
+        textfield.oncut = function (event) {
+          if (word.is_deleted) {
+            // if word is deleted, do not do anything ever again
+            textfield.oncut = null
+            return true
+          }
+          event.preventDefault()
+        }
+        //
+        // consume deletes. Note that
+        //   chrome: won't consume deletions on keypress event.
+        //   keyCode is deprecated. BUT: I don't see another way.
+        //     since event.key is not implemented in the current version of chrome.
+        //     Every browser supports keyCode. Let's stick with it for now..
+        //
+        textfield.onkeydown = function (event) {
+          creatorToken = true
+          if (word.is_deleted) {
+            // if word is deleted, do not do anything ever again
+            textfield.onkeydown = null
+            return true
+          }
+          var r = createRange()
+          var pos = Math.min(r.left, r.right, word.toString().length)
+          var diff = Math.abs(r.left - r.right)
+          if (event.keyCode != null && event.keyCode === 8) { // Backspace
+            if (diff > 0) {
+              word.delete(pos, diff)
+              r.left = pos
+              r.right = pos
+              writeRange(r)
+            } else {
+              if (event.ctrlKey != null && event.ctrlKey) {
+                var val = word.toString()
+                var newPos = pos
+                var delLength = 0
+                if (pos > 0) {
+                  newPos--
+                  delLength++
+                }
+                while (newPos > 0 && val[newPos] !== ' ' && val[newPos] !== '\n') {
+                  newPos--
+                  delLength++
+                }
+                word.delete(newPos, pos - newPos)
+                r.left = newPos
+                r.right = newPos
+                writeRange(r)
+              } else {
+                if (pos > 0) {
+                  word.delete(pos - 1, 1)
+                  r.left = pos - 1
+                  r.right = pos - 1
+                  writeRange(r)
+                }
+              }
+            }
+            event.preventDefault()
+            creatorToken = false
+            return false
+          } else if (event.keyCode != null && event.keyCode === 46) { // Delete
+            if (diff > 0) {
+              word.delete(pos, diff)
+              r.left = pos
+              r.right = pos
+              writeRange(r)
+            } else {
+              word.delete(pos, 1)
+              r.left = pos
+              r.right = pos
+              writeRange(r)
+            }
+            event.preventDefault()
+            creatorToken = false
+            return false
+          } else {
+            creatorToken = false
+            return true
+          }
+        }
+        this.textfields.push({
+          editor: textfield,
+          yCallback: yCallback
+        })
+      }
+    }
+    Y.extend('Text', new Y.utils.CustomType({
+      name: 'Text',
+      class: YText,
+      struct: 'List',
+      initType: function * YTextInitializer (os, model) {
+        var _content = yield* Y.Struct.List.map.call(this, model, function (c) {
+          return {
+            id: JSON.stringify(c.id),
+            val: c.content
+          }
+        })
+        return new YText(os, model.id, _content)
+      }
+    }))
+  })
+}
+
+module.exports = extend
+if (typeof Y !== 'undefined') {
+  extend(Y)
+}
+
+},{}]},{},[1])
+