FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/ltgt/.travis.yml

@@ -0,0 +1,4 @@
+language: node_js
+node_js:
+  - 0.6
+  - 0.8

node_modules/ltgt/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dominic Tarr
+
+Permission is hereby granted, free of charge, 
+to any person obtaining a copy of this software and 
+associated documentation files (the "Software"), to 
+deal in the Software without restriction, including 
+without limitation the rights to use, copy, modify, 
+merge, publish, distribute, sublicense, and/or sell 
+copies of the Software, and to permit persons to whom 
+the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice 
+shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR 
+ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/ltgt/README.md

@@ -0,0 +1,150 @@
+# ltgt
+
+implement correct ranges for level-*
+
+[![build status](https://secure.travis-ci.org/dominictarr/ltgt.png)](http://travis-ci.org/dominictarr/ltgt)
+[![testling badge](https://ci.testling.com/dominictarr/ltgt.png)](https://ci.testling.com/dominictarr/ltgt)
+
+# example
+
+
+``` js
+var ltgt = require('ltgt')
+
+ltgt.start(range) //the start of the range
+ltgt.end(range)   //the end of the range
+
+//returns the lower/upper bound, whether it's inclusive or not.
+ltgt.lowerBound(range)
+ltgt.upperBound(range)
+
+ltgt.lt(range)
+ltgt.gt(range)
+ltgt.lte(range)
+ltgt.gte(range)
+
+//return wether this is a reversed order
+//(this is significant for start/end ranges
+ltgt.reverse(range)
+var filter = ltgt.filter(range)
+
+filter(key) == true //if key contained in range.
+
+ltgt.contains(range, key)
+
+```
+
+# ways to specify ranges
+
+there have been a variety of ways to specify ranges in level-*.
+this module supports them all.
+
+# gt/gte, lt/lte
+
+specify a range between a lower bound (gt, gte) and an upper bound (lt, lte)
+
+if `gte` and `gt` is undefined, read from the start of the database,
+if `lte` and `lt` is undefined, read until the end of the database,
+
+
+# min, max
+
+legacy level-sublevel style,
+synonym for `gte`, `lte`.
+
+# start, end, reverse
+
+legacy levelup style.
+
+The range is from `start` -> `end`, `start` does not specify the lowest
+record, instead it specifies the first record to be read. However,
+`reverse` must also be passed correctly. This is way to specify a range is
+confusing if you need to read in reverse,
+so it's strongly recommended to use `gt/gte,lt/lte`.
+
+If `reverse` is `true`,
+`start` *must* be `undefined` or less than `end`,
+unless `end` is `undefined`.
+
+if `reverse` is `false`
+`end` *must* be `undefined` or greater than `start`,
+unless `start` is `undefined`.
+
+if start is undefined, read from the first record in the database
+if end is undefined read until the last record in the database.
+
+# api
+
+## ltgt.contains(range, key, compare)
+
+using the provided compare method, return `true` if `key`
+is within `range`. compare defaults to `ltgt.compare`
+
+## ltgt.filter(range, compare)
+
+return a function that returns true if it's argument is within range.
+can be passed to `Array.filter`
+
+``` js
+[1,2,3,4,5].filter(ltgt.filter({gt: 2, lte: 4})
+// => [3, 4]
+```
+
+## ltgt.lowerBound(range)
+
+return the lower bound of `range`.
+Incase the lower bound is specified with `gt`,
+check `ltgt.lowerBoundExclusive`
+
+## ltgt.upperBound(range)
+
+return the upperBound of `range`.
+Incase the upper bound is specified with `gt`,
+check `ltgt.upperBoundExclusive`
+
+## ltgt.lowerBoundExclusive(range)
+
+return true if upper bound is exclusive.
+
+## ltgt.upperBoundExclusive(range)
+
+return true if lower bound is exclusive.
+
+## ltgt.start(range, default)
+
+The start of the range. This takes into account direction (reverse)
+If a `start` is not provided, `default` is used.
+
+## ltgt.end(range, default)
+
+The end of the range. This takes into account direction (reverse)
+If a `end` is not provided, `default` is used.
+
+## ltgt.startInclusive(range)
+
+returns true if the range should start at the exact value returned
+by `start(range)` otherwise, it should skip one input.
+
+## ltgt.endInclusive(range)
+
+returns true if the range should include the exact value returned
+by `end(range)` otherwise, it should end on that value.
+
+## ltgt.toLtgt(range, _range, map, lowerBound, upperBound)
+
+convert a range to a new ltgt range. `_range`
+is the object to return - if you want to mutate `range`
+call `ltgt.toLtgt(range, range, map)`
+
+`map` gets called on each key in the range, and wether it's an upper or lower bound -
+so can be used as an encode function.
+
+`map(value, isUpperBound)` if `isUpperBound` is false, this is the lower bound.
+
+## License
+
+MIT
+
+
+
+

node_modules/ltgt/index.js

@@ -0,0 +1,165 @@
+
+exports.compare = function (a, b) {
+
+  if(Buffer.isBuffer(a)) {
+    var l = Math.min(a.length, b.length)
+    for(var i = 0; i < l; i++) {
+      var cmp = a[i] - b[i]
+      if(cmp) return cmp
+    }
+    return a.length - b.length
+  }
+
+  return a < b ? -1 : a > b ? 1 : 0
+}
+
+// to be compatible with the current abstract-leveldown tests
+// nullish or empty strings.
+// I could use !!val but I want to permit numbers and booleans,
+// if possible.
+
+function isDef (val) {
+  return val !== undefined && val !== ''
+}
+
+function has (range, name) {
+  return Object.hasOwnProperty.call(range, name)
+}
+
+function hasKey(range, name) {
+  return Object.hasOwnProperty.call(range, name) && name
+}
+
+var lowerBoundKey = exports.lowerBoundKey = function (range) {
+    return (
+       hasKey(range, 'gt')
+    || hasKey(range, 'gte')
+    || hasKey(range, 'min')
+    || (range.reverse ? hasKey(range, 'end') : hasKey(range, 'start'))
+    || undefined
+    )
+}
+
+var lowerBound = exports.lowerBound = function (range, def) {
+  var k = lowerBoundKey(range)
+  return k ? range[k] : def
+}
+
+var lowerBoundInclusive = exports.lowerBoundInclusive = function (range) {
+  return has(range, 'gt') ? false : true
+}
+
+var upperBoundInclusive = exports.upperBoundInclusive =
+  function (range) {
+    return (has(range, 'lt') /*&& !range.maxEx*/) ? false : true
+  }
+
+var lowerBoundExclusive = exports.lowerBoundExclusive =
+  function (range) {
+    return !lowerBoundInclusive(range)
+  }
+
+var upperBoundExclusive = exports.upperBoundExclusive =
+  function (range) {
+    return !upperBoundInclusive(range)
+  }
+
+var upperBoundKey = exports.upperBoundKey = function (range) {
+    return (
+       hasKey(range, 'lt')
+    || hasKey(range, 'lte')
+    || hasKey(range, 'max')
+    || (range.reverse ? hasKey(range, 'start') : hasKey(range, 'end'))
+    || undefined
+    )
+}
+
+var upperBound = exports.upperBound = function (range, def) {
+  var k = upperBoundKey(range)
+  return k ? range[k] : def
+}
+
+exports.start = function (range, def) {
+  return range.reverse ? upperBound(range, def) : lowerBound(range, def)
+}
+exports.end = function (range, def) {
+  return range.reverse ? lowerBound(range, def) : upperBound(range, def)
+}
+exports.startInclusive = function (range) {
+  return (
+    range.reverse
+  ? upperBoundInclusive(range)
+  : lowerBoundInclusive(range)
+  )
+}
+exports.endInclusive = function (range) {
+  return (
+    range.reverse
+  ? lowerBoundInclusive(range)
+  : upperBoundInclusive(range)
+  )
+}
+
+function id (e) { return e }
+
+exports.toLtgt = function (range, _range, map, lower, upper) {
+  _range = _range || {}
+  map = map || id
+  var defaults = arguments.length > 3
+  var lb = exports.lowerBoundKey(range)
+  var ub = exports.upperBoundKey(range)
+  if(lb) {
+    if(lb === 'gt') _range.gt = map(range.gt, false)
+    else            _range.gte = map(range[lb], false)
+  }
+  else if(defaults)
+    _range.gte = map(lower, false)
+
+  if(ub) {
+    if(ub === 'lt') _range.lt = map(range.lt, true)
+    else            _range.lte = map(range[ub], true)
+  }
+  else if(defaults)
+    _range.lte = map(upper, true)
+
+  if(range.reverse != null)
+    _range.reverse = !!range.reverse
+
+  //if range was used mutably
+  //(in level-sublevel it's part of an options object
+  //that has more properties on it.)
+  if(has(_range, 'max'))   delete _range.max
+  if(has(_range, 'min'))   delete _range.min
+  if(has(_range, 'start')) delete _range.start
+  if(has(_range, 'end'))   delete _range.end
+
+  return _range
+}
+
+exports.contains = function (range, key, compare) {
+  compare = compare || exports.compare
+
+  var lb = lowerBound(range)
+  if(isDef(lb)) {
+    var cmp = compare(key, lb)
+    if(cmp < 0 || (cmp === 0 && lowerBoundExclusive(range)))
+      return false
+  }
+
+  var ub = upperBound(range)
+  if(isDef(ub)) {
+    var cmp = compare(key, ub)
+    if(cmp > 0 || (cmp === 0) && upperBoundExclusive(range))
+      return false
+  }
+
+  return true
+}
+
+exports.filter = function (range, compare) {
+  return function (key) {
+    return exports.contains(range, key, compare)
+  }
+}
+
+

node_modules/ltgt/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "ltgt",
+  "description": "",
+  "version": "2.2.1",
+  "homepage": "https://github.com/dominictarr/ltgt",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/dominictarr/ltgt.git"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tape": "~2.13.1"
+  },
+  "scripts": {
+    "prepublish": "npm ls && node test.js",
+    "test": "node test.js"
+  },
+  "author": "Dominic Tarr <dominic.tarr@gmail.com> (http://dominictarr.com)",
+  "license": "MIT",
+  "testling": {
+    "files": "test.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/17..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}

node_modules/ltgt/test.js

@@ -0,0 +1,380 @@
+var tape = require('tape')
+var ltgt = require('./')
+
+function clone (o) {
+  var O = {}
+  for(var k in o)
+    O[k] = o[k]
+  return O
+}
+
+var elements = [
+  1, 2, 3, 4, 5
+]
+
+var ranges = [
+  //default
+  { range:
+      {},
+    selection:
+      elements
+  },
+  { range:
+      {reverse: true },
+    selection:
+      elements.slice().reverse()
+  },
+
+  //start/end - this has a lot of semantics because reverse is significant.
+  { range:
+      {start: 2},
+    selection:
+      [2, 3, 4, 5]
+  },
+  { range:
+      {start: 2, reverse: true},
+    selection:
+      [2, 1]
+  },
+  { range:
+      {end: 2},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {end: 2, reverse: true},
+    selection:
+      [2, 3, 4, 5].reverse()
+  },
+  { range:
+      {start: 2.5},
+    selection:
+      [3, 4, 5]
+  },
+  { range:
+      {start: 2.5, reverse: true},
+    selection:
+      [2, 1]
+  },
+  { range:
+      {end: 2.5, reverse: true},
+    selection:
+      [5, 4, 3]
+  },
+  { range:
+      {start: 5},
+    selection:
+      [5]
+  },
+  { range:
+      {start: 5.5},
+    selection:
+      []
+  },
+  { range:
+      {end: 0.5},
+    selection:
+      []
+  },
+  { range:
+      {start: 5.5, reverse: true},
+    selection:
+      [5, 4, 3, 2, 1]
+  },
+  { range:
+      {end: 0.5, reverse: true},
+    selection:
+      [5, 4, 3, 2, 1]
+  },
+
+  //nullish and empty strings signify are streated like null!
+  { range:
+      {end: null, reverse: true},
+    selection:
+      [5, 4, 3, 2, 1]
+  },
+  { range:
+      {end: undefined, reverse: true},
+    selection:
+      [5, 4, 3, 2, 1]
+  },
+  { range:
+      {end: '', reverse: true},
+    selection:
+      [5, 4, 3, 2, 1]
+  },
+
+  //lt/gt/lte/gte
+
+  { range:
+      {lt: 2.5},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {gt: 2.5},
+    selection:
+      [3, 4, 5]
+  },
+  { range:
+      {lt: 2},
+    selection:
+      [1]
+  },
+  { range:
+      {gt: 2},
+    selection:
+      [3, 4, 5]
+  },
+
+  { range:
+      {lte: 2.5},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {gte: 2.5},
+    selection:
+      [3, 4, 5]
+  },
+  { range:
+      {lte: 2},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {gte: 2},
+    selection:
+      [2, 3, 4, 5]
+  },
+
+  { range:
+      {gt: 2.5, lt: 5},
+    selection:
+      [3, 4]
+  },
+  { range:
+      {gte: 2, lt: 3.5},
+    selection:
+      [2, 3]
+  },
+  { range:
+      {gt: 2.5, lte: 4},
+    selection:
+      [3, 4]
+  },
+  { range:
+      {gte: 2, lte: 4},
+    selection:
+      [2, 3, 4]
+  },
+
+  //min/max - used by sublevel, equiv to gte, lte
+
+  { range:
+      {min: 2, max: 4},
+    selection:
+      [2, 3, 4]
+  },
+
+  { range:
+      {max: 2.5},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {min: 2.5},
+    selection:
+      [3, 4, 5]
+  },
+  { range:
+      {max: 2},
+    selection:
+      [1, 2]
+  },
+  { range:
+      {min: 2},
+    selection:
+      [2, 3, 4, 5]
+  }
+
+]
+
+
+tape('upperBound', function (t) {
+  t.equal('b', ltgt.upperBound({start: 'b', reverse: true}))
+  t.equal('b', ltgt.upperBound({end: 'b', reverse: false}))
+  t.equal(undefined, ltgt.lowerBound({start: 'b', reverse: true}))
+  t.equal(undefined, ltgt.lowerBound({end: 'b', reverse: false}))
+  t.end()
+})
+
+tape('bounds and inclusive', function (t) {
+//  t.equal(ltgt.upperBound({start: 'b', reverse: true}), 'b')
+//  t.equal(ltgt.upperBoundInclusive({start: 'b', reverse: true}), true)
+//  t.equal(ltgt.upperBound({end: 'b', reverse: false}), 'b')
+//
+//  t.equal(ltgt.lowerBound({start: 'b', reverse: true}), undefined)
+//  t.equal(ltgt.lowerBound({end: 'b', reverse: false}), undefined)
+//  t.equal(ltgt.upperBoundInclusive({start: 'b', reverse: true}), true)
+//  t.equal(ltgt.upperBoundInclusive({end: 'b', reverse: false}), true)
+//
+  t.equal(ltgt.upperBound({lt: 'b', reverse: true}), 'b')
+  t.equal(ltgt.upperBound({lte: 'b', reverse: true}), 'b')
+
+  t.equal(ltgt.upperBound({lt: 'b'}), 'b')
+  t.equal(ltgt.upperBound({lte: 'b'}), 'b')
+
+  t.equal(ltgt.upperBoundInclusive({lt: 'b'}), false)
+
+  t.equal(ltgt.upperBoundInclusive({lte: 'b'}), true)
+
+  t.equal(ltgt.lowerBoundInclusive({gt: 'b'}), false)
+  t.equal(ltgt.lowerBoundInclusive({gte: 'b'}), true)
+
+
+  t.end()
+})
+
+
+tape('start, end', function (t) {
+//  t.equal(ltgt.upperBound({start: 'b', reverse: true}), 'b')
+//  t.equal(ltgt.upperBoundInclusive({start: 'b', reverse: true}), true)
+//  t.equal(ltgt.upperBound({end: 'b', reverse: false}), 'b')
+//
+//  t.equal(ltgt.lowerBound({start: 'b', reverse: true}), undefined)
+//  t.equal(ltgt.lowerBound({end: 'b', reverse: false}), undefined)
+//  t.equal(ltgt.upperBoundInclusive({start: 'b', reverse: true}), true)
+//  t.equal(ltgt.upperBoundInclusive({end: 'b', reverse: false}), true)
+
+  t.equal(ltgt.start({lt: 'b', reverse: true}), 'b')
+  t.equal(ltgt.start({lte: 'b', reverse: true}), 'b')
+  t.equal(ltgt.end({lt: 'b', reverse: true}, null), null)
+  t.equal(ltgt.end({lte: 'b', reverse: true}, null), null)
+
+  t.equal(ltgt.end({lt: 'b'}), 'b')
+  t.equal(ltgt.end({lte: 'b'}), 'b')
+  t.equal(ltgt.start({lt: 'b'}, undefined), undefined)
+  t.equal(ltgt.start({lte: 'b'}, undefined), undefined)
+
+  t.equal(ltgt.endInclusive({lt: 'b'}), false)
+
+  t.equal(ltgt.endInclusive({lte: 'b'}), true)
+
+  t.equal(ltgt.startInclusive({gt: 'b'}), false)
+  t.equal(ltgt.startInclusive({gte: 'b'}), true)
+
+
+  t.end()
+})
+
+
+var strings = ['00', '01', '02']
+var sranges = [
+  {range:
+    {start: '00'},
+    selection:
+      ['00', '01', '02']
+  },
+  {range:
+    {start: '03', reverse: true},
+    selection:
+      ['02', '01', '00']
+  },
+
+]
+function compare (a, b) {
+  return a - b
+}
+
+make(elements, ranges)
+
+make(strings, sranges)
+make(elements.map(String), ranges.map(function (e) {
+  var r = {}
+  for(var k in e.range)
+    if('number' === typeof e.range[k])
+      r[k] = e.range.toString()
+  return {range: e.range, selection: e.selection.map(String)}
+}))
+
+function make (elements, ranges) {
+
+  ranges.forEach(function (e) {
+
+    tape(JSON.stringify(e.range) + ' => '+ JSON.stringify(e.selection),
+      function (t) {
+        var actual = elements.filter(ltgt.filter(e.range))
+        if(e.range.reverse)
+          actual.reverse()
+        t.deepEqual(actual, e.selection, 'test range:' + JSON.stringify(e.range))
+
+        var range = ltgt.toLtgt(e.range)
+        //should not just return the same thing.
+        t.notOk(range.min || range.max || range.start || range.end)
+
+        var actual2 = elements.filter(ltgt.filter(range))
+        if(e.range.reverse)
+          actual2.reverse()
+        t.deepEqual(actual2, e.selection)
+        
+        t.end()
+      })
+  })
+}
+
+
+function createLtgtTests(mutate) {
+  return function (t) {
+    function map (key) {
+      return 'foo!' + key
+    }
+
+    function T (expected, input) {
+      input = clone(input)
+      t.deepEqual(
+        expected,
+        ltgt.toLtgt(input, mutate ? input : null, map, '!', '~')
+      )
+    }
+
+    //start, end
+
+    T({gte: 'foo!a', lte: 'foo!b'}, {start: 'a', end:'b'})
+    T({gte: 'foo!a', lte: 'foo!~'}, {start: 'a'})
+    T({gte: 'foo!!', lte: 'foo!b'}, {end: 'b'})
+
+    T({gte: 'foo!a', lte: 'foo!b', reverse: true},
+      {start: 'b', end: 'a', reverse: true})
+
+    // min, max
+
+    T({gte: 'foo!a', lte: 'foo!b'}, {min: 'a', max:'b'})
+    T({gte: 'foo!a', lte: 'foo!~'}, {min: 'a'})
+    T({gte: 'foo!!', lte: 'foo!b'}, {max: 'b'})
+    T({gte: 'foo!!', lte: 'foo!~'}, {})
+
+    // lt, gt
+
+    T({gt: 'foo!a', lt: 'foo!b'}, {gt: 'a', lt:'b'})
+    T({gt: 'foo!a', lte: 'foo!~'}, {gt: 'a'})
+    T({gte: 'foo!!', lt: 'foo!b'}, {lt: 'b'})
+    T({gte: 'foo!!', lte: 'foo!~'}, {})
+
+    // lt, gt
+
+    T({gte: 'foo!a', lte: 'foo!b'}, {gte: 'a', lte:'b'})
+    T({gte: 'foo!a', lte: 'foo!~'}, {gte: 'a'})
+    T({gte: 'foo!!', lte: 'foo!b'}, {lte: 'b'})
+    T({gte: 'foo!!', lte: 'foo!~'}, {})
+
+    t.end()
+  }
+}
+
+tape('toLtgt - immutable', createLtgtTests(false))
+tape('toLtgt - mutable', createLtgtTests(true))
+
+
+
+