loose_leaf 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/MIT-LICENSE +21 -0
- data/README.md +136 -0
- data/Rakefile +29 -0
- data/app/assets/javascripts/loose_leaf/index.js +3408 -0
- data/app/channels/loose_leaf/collaboration_channel.rb +56 -0
- data/app/controllers/loose_leaf/application_controller.rb +4 -0
- data/lib/loose_leaf.rb +8 -0
- data/lib/loose_leaf/document.rb +99 -0
- data/lib/loose_leaf/document_attribute.rb +90 -0
- data/lib/loose_leaf/engine.rb +16 -0
- data/lib/loose_leaf/version.rb +3 -0
- data/lib/tasks/loose_leaf_tasks.rake +4 -0
- metadata +342 -0
checksums.yaml
ADDED
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
---
|
|
2
|
+
SHA1:
|
|
3
|
+
metadata.gz: 37fd14f6f259b07014bf83e22f256491738d6a44
|
|
4
|
+
data.tar.gz: 908f93f8a735d94a554933f1f0ba4696e1486c7b
|
|
5
|
+
SHA512:
|
|
6
|
+
metadata.gz: 7d7fded0b64c6e35b3942e76848f1f986d11e258455c33f0c2446911409a5ddb6bb54723bb6069a26e41272c5999b44cece90fdcb954b3aea9beae8f22f7dd8c
|
|
7
|
+
data.tar.gz: 039596f3ea7fbdc0cdaf948de57ed4c107c4dc2cc546c1ba915e3044702ee7fda9ae147f072f5706eedbfc37e8c603913f88af795d0d2e259753414deab89d57
|
data/MIT-LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
Copyright 2015 Hayden Ball
|
|
2
|
+
Copyright 2016 Akira Takahashi
|
|
3
|
+
|
|
4
|
+
Permission is hereby granted, free of charge, to any person obtaining
|
|
5
|
+
a copy of this software and associated documentation files (the
|
|
6
|
+
"Software"), to deal in the Software without restriction, including
|
|
7
|
+
without limitation the rights to use, copy, modify, merge, publish,
|
|
8
|
+
distribute, sublicense, and/or sell copies of the Software, and to
|
|
9
|
+
permit persons to whom the Software is furnished to do so, subject to
|
|
10
|
+
the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be
|
|
13
|
+
included in all copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
16
|
+
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
17
|
+
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
18
|
+
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
19
|
+
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
20
|
+
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
21
|
+
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
data/README.md
ADDED
|
@@ -0,0 +1,136 @@
|
|
|
1
|
+
# LooseLeaf [](https://travis-ci.org/rike422/loose-leaf) [](https://coveralls.io/github/rike422/loose-leaf?branch=master) [](https://codeclimate.com/github/rike422/loose-leaf) [](http://standardjs.com/)
|
|
2
|
+
|
|
3
|
+
|
|
4
|
+
LooseLeaf is a Rails Engine that allows Real-Time collaboration between users.
|
|
5
|
+
|
|
6
|
+
LooseLeaf is still a work in progress, and currently only text attributes may
|
|
7
|
+
be collaboratively text editor.
|
|
8
|
+
|
|
9
|
+
This project inspired by [Collabrate](https://github.com/ball-hayden/Collaborate)
|
|
10
|
+
|
|
11
|
+
## Installation
|
|
12
|
+
|
|
13
|
+
Add this line to your application's Gemfile:
|
|
14
|
+
|
|
15
|
+
```ruby
|
|
16
|
+
gem 'together'
|
|
17
|
+
```
|
|
18
|
+
|
|
19
|
+
And then execute:
|
|
20
|
+
|
|
21
|
+
$ bundle
|
|
22
|
+
|
|
23
|
+
## Getting Started
|
|
24
|
+
|
|
25
|
+
### Prerequisites
|
|
26
|
+
|
|
27
|
+
You will need to have ActionCable set up. In particular, you will need an
|
|
28
|
+
`ApplicationCable::Channel` and `ApplicationCable::Connection`.
|
|
29
|
+
|
|
30
|
+
More information about setting up ActionCable can be found in its README.
|
|
31
|
+
|
|
32
|
+
### Model Setup
|
|
33
|
+
|
|
34
|
+
```ruby
|
|
35
|
+
class Document < ActiveRecord::Base
|
|
36
|
+
# Include the LooseLeaf::Document concern
|
|
37
|
+
include LooseLeaf::Document
|
|
38
|
+
|
|
39
|
+
# Choose which attributes may be edited collaboratively
|
|
40
|
+
collaborative_attributes :body, :title
|
|
41
|
+
end
|
|
42
|
+
```
|
|
43
|
+
|
|
44
|
+
Adding `collaborative_attributes` will define an extra attribute on the model
|
|
45
|
+
prefixed with `collaborative_` (e.g `collaborative_body`). We must use that
|
|
46
|
+
over `body` whenever we wish to allow realtime collaboration.
|
|
47
|
+
|
|
48
|
+
Bear in mind that the `collaborative_` attributes are stored only in the Rails
|
|
49
|
+
cache. You must save these attributes where appropriate:
|
|
50
|
+
|
|
51
|
+
```ruby
|
|
52
|
+
document = Document.first
|
|
53
|
+
document.body = document.collaborative_body
|
|
54
|
+
document.save!
|
|
55
|
+
|
|
56
|
+
# Or, using the commit_collaborative_attributes convenience method:
|
|
57
|
+
|
|
58
|
+
document.commit_collaborative_attributes(:body)
|
|
59
|
+
document.commit_collaborative_attributes(:body, :title)
|
|
60
|
+
|
|
61
|
+
```
|
|
62
|
+
|
|
63
|
+
### Channel Setup
|
|
64
|
+
|
|
65
|
+
You will need to set up a collaboration channel for each model that is being
|
|
66
|
+
collaboratively edited.
|
|
67
|
+
|
|
68
|
+
```ruby
|
|
69
|
+
class DocumentChannel < LooseLeaf::CollaborationChannel
|
|
70
|
+
private
|
|
71
|
+
|
|
72
|
+
# Set the Model class that we are editing.
|
|
73
|
+
def collaborative_model
|
|
74
|
+
Document
|
|
75
|
+
end
|
|
76
|
+
end
|
|
77
|
+
```
|
|
78
|
+
|
|
79
|
+
### View
|
|
80
|
+
|
|
81
|
+
As mentioned in Model Setup, we must use `collaborative_` attributes over normal
|
|
82
|
+
attributes when getting the values of collaborative attributes:
|
|
83
|
+
|
|
84
|
+
```erb
|
|
85
|
+
<%# app/views/documents/show.html.erb %>
|
|
86
|
+
|
|
87
|
+
<input id="title" type="text" value="<%= @document.collaborative_title %>">
|
|
88
|
+
|
|
89
|
+
<textarea id="body" rows="8" cols="40"><%= @document.collaborative_body %></textarea>
|
|
90
|
+
|
|
91
|
+
<%= link_to 'Back', documents_path %>
|
|
92
|
+
|
|
93
|
+
<script>
|
|
94
|
+
var documentId = <%= @document.id %>
|
|
95
|
+
</script>
|
|
96
|
+
```
|
|
97
|
+
|
|
98
|
+
### JavaScript
|
|
99
|
+
|
|
100
|
+
[](https://github.com/feross/standard)
|
|
101
|
+
|
|
102
|
+
#### Sprockets
|
|
103
|
+
|
|
104
|
+
Add `loose-leaf` to your `application.coffee` asset, after actionable:
|
|
105
|
+
|
|
106
|
+
```coffeescript
|
|
107
|
+
#= require cable
|
|
108
|
+
#= require loose-leaf
|
|
109
|
+
```
|
|
110
|
+
|
|
111
|
+
Then, wherever appropriate:
|
|
112
|
+
|
|
113
|
+
```js
|
|
114
|
+
|
|
115
|
+
// Create a new ActionCable consumer
|
|
116
|
+
const cable = Cable.createConsumer('ws://localhost:28080')
|
|
117
|
+
|
|
118
|
+
// Set up our collaboration object. `documentId` is (as you may expect) the ID
|
|
119
|
+
// of the document that is being edited.
|
|
120
|
+
const looseLeaf = new LooseLeaf(cable, 'DocumentChannel', documentId)
|
|
121
|
+
|
|
122
|
+
// We now specify the two attributes we are editing.
|
|
123
|
+
collaborativeTitle = looseLeaf.addAttribute('title')
|
|
124
|
+
collaborativeBody = looseLeaf.addAttribute('body')
|
|
125
|
+
|
|
126
|
+
new LooseLeaf.Adapters.TextAreaAdapter(collaborativeTitle, '#title')
|
|
127
|
+
new LooseLeaf.Adapters.TextAreaAdapter(collaborativeBody, '#body')
|
|
128
|
+
|
|
129
|
+
```
|
|
130
|
+
|
|
131
|
+
#### npm or yuan
|
|
132
|
+
|
|
133
|
+
```
|
|
134
|
+
npm install loose-leaf
|
|
135
|
+
```
|
|
136
|
+
|
data/Rakefile
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
1
|
+
begin
|
|
2
|
+
require 'bundler/setup'
|
|
3
|
+
rescue LoadError
|
|
4
|
+
puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
|
|
5
|
+
end
|
|
6
|
+
|
|
7
|
+
APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
|
|
8
|
+
|
|
9
|
+
require 'rdoc/task'
|
|
10
|
+
|
|
11
|
+
RDoc::Task.new(:rdoc) do |rdoc|
|
|
12
|
+
rdoc.rdoc_dir = 'rdoc'
|
|
13
|
+
rdoc.title = 'LooseLeaf'
|
|
14
|
+
rdoc.options << '--line-numbers'
|
|
15
|
+
rdoc.rdoc_files.include('README.md')
|
|
16
|
+
rdoc.rdoc_files.include('lib/**/*.rb')
|
|
17
|
+
end
|
|
18
|
+
|
|
19
|
+
require 'bundler/gem_tasks'
|
|
20
|
+
|
|
21
|
+
require 'rspec/core/rake_task'
|
|
22
|
+
|
|
23
|
+
load 'rails/tasks/engine.rake'
|
|
24
|
+
load 'rails/tasks/statistics.rake'
|
|
25
|
+
|
|
26
|
+
Bundler::GemHelper.install_tasks
|
|
27
|
+
|
|
28
|
+
RSpec::Core::RakeTask.new(:spec)
|
|
29
|
+
task default: [:spec, :lint]
|
|
@@ -0,0 +1,3408 @@
|
|
|
1
|
+
(function webpackUniversalModuleDefinition(root, factory) {
|
|
2
|
+
if(typeof exports === 'object' && typeof module === 'object')
|
|
3
|
+
module.exports = factory();
|
|
4
|
+
else if(typeof define === 'function' && define.amd)
|
|
5
|
+
define([], factory);
|
|
6
|
+
else if(typeof exports === 'object')
|
|
7
|
+
exports["LooseLeaf"] = factory();
|
|
8
|
+
else
|
|
9
|
+
root["LooseLeaf"] = factory();
|
|
10
|
+
})(this, function() {
|
|
11
|
+
return /******/ (function(modules) { // webpackBootstrap
|
|
12
|
+
/******/ // The module cache
|
|
13
|
+
/******/ var installedModules = {};
|
|
14
|
+
|
|
15
|
+
/******/ // The require function
|
|
16
|
+
/******/ function __webpack_require__(moduleId) {
|
|
17
|
+
|
|
18
|
+
/******/ // Check if module is in cache
|
|
19
|
+
/******/ if(installedModules[moduleId])
|
|
20
|
+
/******/ return installedModules[moduleId].exports;
|
|
21
|
+
|
|
22
|
+
/******/ // Create a new module (and put it into the cache)
|
|
23
|
+
/******/ var module = installedModules[moduleId] = {
|
|
24
|
+
/******/ exports: {},
|
|
25
|
+
/******/ id: moduleId,
|
|
26
|
+
/******/ loaded: false
|
|
27
|
+
/******/ };
|
|
28
|
+
|
|
29
|
+
/******/ // Execute the module function
|
|
30
|
+
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
31
|
+
|
|
32
|
+
/******/ // Flag the module as loaded
|
|
33
|
+
/******/ module.loaded = true;
|
|
34
|
+
|
|
35
|
+
/******/ // Return the exports of the module
|
|
36
|
+
/******/ return module.exports;
|
|
37
|
+
/******/ }
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
/******/ // expose the modules object (__webpack_modules__)
|
|
41
|
+
/******/ __webpack_require__.m = modules;
|
|
42
|
+
|
|
43
|
+
/******/ // expose the module cache
|
|
44
|
+
/******/ __webpack_require__.c = installedModules;
|
|
45
|
+
|
|
46
|
+
/******/ // __webpack_public_path__
|
|
47
|
+
/******/ __webpack_require__.p = "";
|
|
48
|
+
|
|
49
|
+
/******/ // Load entry module and return exports
|
|
50
|
+
/******/ return __webpack_require__(0);
|
|
51
|
+
/******/ })
|
|
52
|
+
/************************************************************************/
|
|
53
|
+
/******/ ([
|
|
54
|
+
/* 0 */
|
|
55
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
56
|
+
|
|
57
|
+
'use strict';
|
|
58
|
+
|
|
59
|
+
var _looseLeaf = __webpack_require__(1);
|
|
60
|
+
|
|
61
|
+
var _looseLeaf2 = _interopRequireDefault(_looseLeaf);
|
|
62
|
+
|
|
63
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
64
|
+
|
|
65
|
+
module.exports = _looseLeaf2.default; // weak
|
|
66
|
+
|
|
67
|
+
/***/ },
|
|
68
|
+
/* 1 */
|
|
69
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
70
|
+
|
|
71
|
+
'use strict';
|
|
72
|
+
|
|
73
|
+
Object.defineProperty(exports, "__esModule", {
|
|
74
|
+
value: true
|
|
75
|
+
});
|
|
76
|
+
exports.default = undefined;
|
|
77
|
+
|
|
78
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
79
|
+
|
|
80
|
+
var _class, _temp; // weak
|
|
81
|
+
|
|
82
|
+
var _attributeCable = __webpack_require__(2);
|
|
83
|
+
|
|
84
|
+
var _attributeCable2 = _interopRequireDefault(_attributeCable);
|
|
85
|
+
|
|
86
|
+
var _index = __webpack_require__(23);
|
|
87
|
+
|
|
88
|
+
var _index2 = _interopRequireDefault(_index);
|
|
89
|
+
|
|
90
|
+
var _cable = __webpack_require__(22);
|
|
91
|
+
|
|
92
|
+
var _cable2 = _interopRequireDefault(_cable);
|
|
93
|
+
|
|
94
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
95
|
+
|
|
96
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
97
|
+
|
|
98
|
+
var _events = __webpack_require__(25);
|
|
99
|
+
|
|
100
|
+
var _events2 = _interopRequireDefault(_events);
|
|
101
|
+
|
|
102
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
103
|
+
|
|
104
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
105
|
+
|
|
106
|
+
var LooseLeaf = (_temp = _class = function () {
|
|
107
|
+
function LooseLeaf(cable, channel, documentId) {
|
|
108
|
+
_classCallCheck(this, LooseLeaf);
|
|
109
|
+
|
|
110
|
+
this.documentId = documentId;
|
|
111
|
+
this.cable = new _cable2.default(this, cable, channel);
|
|
112
|
+
this.attributes = {};
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
_createClass(LooseLeaf, [{
|
|
116
|
+
key: 'addAttribute',
|
|
117
|
+
value: function addAttribute(attribute) {
|
|
118
|
+
this.attributes[attribute] = new _collaborativeAttribute2.default(this, attribute);
|
|
119
|
+
return this.attributes[attribute];
|
|
120
|
+
}
|
|
121
|
+
}, {
|
|
122
|
+
key: 'destroy',
|
|
123
|
+
value: function destroy() {
|
|
124
|
+
Object.values(this.attributes).forEach(function (attribute) {
|
|
125
|
+
return attribute.destroy();
|
|
126
|
+
});
|
|
127
|
+
this.cable.destroy();
|
|
128
|
+
}
|
|
129
|
+
}]);
|
|
130
|
+
|
|
131
|
+
return LooseLeaf;
|
|
132
|
+
}(), _class.AttributeCable = _attributeCable2.default, _class.Adapters = _index2.default, _class.Cable = _cable2.default, _class.CollaborativeAttribute = _collaborativeAttribute2.default, _class.Events = _events2.default, _temp);
|
|
133
|
+
exports.default = LooseLeaf;
|
|
134
|
+
;
|
|
135
|
+
|
|
136
|
+
/***/ },
|
|
137
|
+
/* 2 */
|
|
138
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
139
|
+
|
|
140
|
+
'use strict';
|
|
141
|
+
|
|
142
|
+
Object.defineProperty(exports, "__esModule", {
|
|
143
|
+
value: true
|
|
144
|
+
});
|
|
145
|
+
exports.default = undefined;
|
|
146
|
+
|
|
147
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // weak
|
|
148
|
+
|
|
149
|
+
var _ot = __webpack_require__(3);
|
|
150
|
+
|
|
151
|
+
var _ot2 = _interopRequireDefault(_ot);
|
|
152
|
+
|
|
153
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
154
|
+
|
|
155
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
156
|
+
|
|
157
|
+
var _cable = __webpack_require__(22);
|
|
158
|
+
|
|
159
|
+
var _cable2 = _interopRequireDefault(_cable);
|
|
160
|
+
|
|
161
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
162
|
+
|
|
163
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
164
|
+
|
|
165
|
+
var AttributeCable = function () {
|
|
166
|
+
function AttributeCable(collaborativeAttribute, cable, attribute) {
|
|
167
|
+
_classCallCheck(this, AttributeCable);
|
|
168
|
+
|
|
169
|
+
this.collaborativeAttribute = collaborativeAttribute;
|
|
170
|
+
this.cable = cable;
|
|
171
|
+
this.attribute = attribute;
|
|
172
|
+
this.unackedOps = [];
|
|
173
|
+
this.version = 0;
|
|
174
|
+
this.cable.addAttribute(this.attribute, this);
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
_createClass(AttributeCable, [{
|
|
178
|
+
key: 'destroy',
|
|
179
|
+
value: function destroy() {
|
|
180
|
+
this.cable.removeAttribute(this.attribute);
|
|
181
|
+
true;
|
|
182
|
+
}
|
|
183
|
+
}, {
|
|
184
|
+
key: 'receiveAttribute',
|
|
185
|
+
value: function receiveAttribute(data) {
|
|
186
|
+
this.version = data.version;
|
|
187
|
+
}
|
|
188
|
+
}, {
|
|
189
|
+
key: 'sendOperation',
|
|
190
|
+
value: function sendOperation(data) {
|
|
191
|
+
this.version++;
|
|
192
|
+
data.attribute = this.attribute;
|
|
193
|
+
data.version = this.version;
|
|
194
|
+
|
|
195
|
+
console.log('Send ' + this.attribute + ' version ' + data.version + ': ' + data.operation.toString());
|
|
196
|
+
|
|
197
|
+
this.unackedOps.push(data.version);
|
|
198
|
+
return this.cable.sendOperation(data);
|
|
199
|
+
}
|
|
200
|
+
}, {
|
|
201
|
+
key: 'receiveOperation',
|
|
202
|
+
value: function receiveOperation(data) {
|
|
203
|
+
data.operation = _ot2.default.TextOperation.fromJSON(data.operation);
|
|
204
|
+
this.version = data.version;
|
|
205
|
+
|
|
206
|
+
console.log('Receive ' + this.attribute + ' version ' + data.version + ': ' + data.operation.toString() + ' from ' + data.client_id);
|
|
207
|
+
|
|
208
|
+
if (data.client_id === this.cable.clientId) {
|
|
209
|
+
return this.receiveAck(data);
|
|
210
|
+
} else {
|
|
211
|
+
return this.receiveRemoteOperation(data);
|
|
212
|
+
}
|
|
213
|
+
}
|
|
214
|
+
}, {
|
|
215
|
+
key: 'receiveAck',
|
|
216
|
+
value: function receiveAck(data) {
|
|
217
|
+
var ackIndex = this.unackedOps.indexOf(data.sent_version);
|
|
218
|
+
|
|
219
|
+
if (ackIndex > -1) {
|
|
220
|
+
this.unackedOps.splice(ackIndex, 1);
|
|
221
|
+
this.collaborativeAttribute.receiveAck(data);
|
|
222
|
+
} else {
|
|
223
|
+
console.warn('Operation ' + data.sent_version + ' reAcked');
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
}, {
|
|
227
|
+
key: 'receiveRemoteOperation',
|
|
228
|
+
value: function receiveRemoteOperation(data) {
|
|
229
|
+
return this.collaborativeAttribute.remoteOperation(data);
|
|
230
|
+
}
|
|
231
|
+
}]);
|
|
232
|
+
|
|
233
|
+
return AttributeCable;
|
|
234
|
+
}();
|
|
235
|
+
|
|
236
|
+
exports.default = AttributeCable;
|
|
237
|
+
;
|
|
238
|
+
|
|
239
|
+
/***/ },
|
|
240
|
+
/* 3 */
|
|
241
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
242
|
+
|
|
243
|
+
exports.version = '0.0.15';
|
|
244
|
+
|
|
245
|
+
exports.TextOperation = __webpack_require__(4);
|
|
246
|
+
exports.SimpleTextOperation = __webpack_require__(5);
|
|
247
|
+
exports.Client = __webpack_require__(6);
|
|
248
|
+
exports.Server = __webpack_require__(7);
|
|
249
|
+
exports.Selection = __webpack_require__(8);
|
|
250
|
+
exports.EditorSocketIOServer = __webpack_require__(9);
|
|
251
|
+
|
|
252
|
+
|
|
253
|
+
/***/ },
|
|
254
|
+
/* 4 */
|
|
255
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
256
|
+
|
|
257
|
+
if (typeof ot === 'undefined') {
|
|
258
|
+
// Export for browsers
|
|
259
|
+
var ot = {};
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
ot.TextOperation = (function () {
|
|
263
|
+
'use strict';
|
|
264
|
+
|
|
265
|
+
// Constructor for new operations.
|
|
266
|
+
function TextOperation () {
|
|
267
|
+
if (!this || this.constructor !== TextOperation) {
|
|
268
|
+
// => function was called without 'new'
|
|
269
|
+
return new TextOperation();
|
|
270
|
+
}
|
|
271
|
+
|
|
272
|
+
// When an operation is applied to an input string, you can think of this as
|
|
273
|
+
// if an imaginary cursor runs over the entire string and skips over some
|
|
274
|
+
// parts, deletes some parts and inserts characters at some positions. These
|
|
275
|
+
// actions (skip/delete/insert) are stored as an array in the "ops" property.
|
|
276
|
+
this.ops = [];
|
|
277
|
+
// An operation's baseLength is the length of every string the operation
|
|
278
|
+
// can be applied to.
|
|
279
|
+
this.baseLength = 0;
|
|
280
|
+
// The targetLength is the length of every string that results from applying
|
|
281
|
+
// the operation on a valid input string.
|
|
282
|
+
this.targetLength = 0;
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
TextOperation.prototype.equals = function (other) {
|
|
286
|
+
if (this.baseLength !== other.baseLength) { return false; }
|
|
287
|
+
if (this.targetLength !== other.targetLength) { return false; }
|
|
288
|
+
if (this.ops.length !== other.ops.length) { return false; }
|
|
289
|
+
for (var i = 0; i < this.ops.length; i++) {
|
|
290
|
+
if (this.ops[i] !== other.ops[i]) { return false; }
|
|
291
|
+
}
|
|
292
|
+
return true;
|
|
293
|
+
};
|
|
294
|
+
|
|
295
|
+
// Operation are essentially lists of ops. There are three types of ops:
|
|
296
|
+
//
|
|
297
|
+
// * Retain ops: Advance the cursor position by a given number of characters.
|
|
298
|
+
// Represented by positive ints.
|
|
299
|
+
// * Insert ops: Insert a given string at the current cursor position.
|
|
300
|
+
// Represented by strings.
|
|
301
|
+
// * Delete ops: Delete the next n characters. Represented by negative ints.
|
|
302
|
+
|
|
303
|
+
var isRetain = TextOperation.isRetain = function (op) {
|
|
304
|
+
return typeof op === 'number' && op > 0;
|
|
305
|
+
};
|
|
306
|
+
|
|
307
|
+
var isInsert = TextOperation.isInsert = function (op) {
|
|
308
|
+
return typeof op === 'string';
|
|
309
|
+
};
|
|
310
|
+
|
|
311
|
+
var isDelete = TextOperation.isDelete = function (op) {
|
|
312
|
+
return typeof op === 'number' && op < 0;
|
|
313
|
+
};
|
|
314
|
+
|
|
315
|
+
|
|
316
|
+
// After an operation is constructed, the user of the library can specify the
|
|
317
|
+
// actions of an operation (skip/insert/delete) with these three builder
|
|
318
|
+
// methods. They all return the operation for convenient chaining.
|
|
319
|
+
|
|
320
|
+
// Skip over a given number of characters.
|
|
321
|
+
TextOperation.prototype.retain = function (n) {
|
|
322
|
+
if (typeof n !== 'number') {
|
|
323
|
+
throw new Error("retain expects an integer");
|
|
324
|
+
}
|
|
325
|
+
if (n === 0) { return this; }
|
|
326
|
+
this.baseLength += n;
|
|
327
|
+
this.targetLength += n;
|
|
328
|
+
if (isRetain(this.ops[this.ops.length-1])) {
|
|
329
|
+
// The last op is a retain op => we can merge them into one op.
|
|
330
|
+
this.ops[this.ops.length-1] += n;
|
|
331
|
+
} else {
|
|
332
|
+
// Create a new op.
|
|
333
|
+
this.ops.push(n);
|
|
334
|
+
}
|
|
335
|
+
return this;
|
|
336
|
+
};
|
|
337
|
+
|
|
338
|
+
// Insert a string at the current position.
|
|
339
|
+
TextOperation.prototype.insert = function (str) {
|
|
340
|
+
if (typeof str !== 'string') {
|
|
341
|
+
throw new Error("insert expects a string");
|
|
342
|
+
}
|
|
343
|
+
if (str === '') { return this; }
|
|
344
|
+
this.targetLength += str.length;
|
|
345
|
+
var ops = this.ops;
|
|
346
|
+
if (isInsert(ops[ops.length-1])) {
|
|
347
|
+
// Merge insert op.
|
|
348
|
+
ops[ops.length-1] += str;
|
|
349
|
+
} else if (isDelete(ops[ops.length-1])) {
|
|
350
|
+
// It doesn't matter when an operation is applied whether the operation
|
|
351
|
+
// is delete(3), insert("something") or insert("something"), delete(3).
|
|
352
|
+
// Here we enforce that in this case, the insert op always comes first.
|
|
353
|
+
// This makes all operations that have the same effect when applied to
|
|
354
|
+
// a document of the right length equal in respect to the `equals` method.
|
|
355
|
+
if (isInsert(ops[ops.length-2])) {
|
|
356
|
+
ops[ops.length-2] += str;
|
|
357
|
+
} else {
|
|
358
|
+
ops[ops.length] = ops[ops.length-1];
|
|
359
|
+
ops[ops.length-2] = str;
|
|
360
|
+
}
|
|
361
|
+
} else {
|
|
362
|
+
ops.push(str);
|
|
363
|
+
}
|
|
364
|
+
return this;
|
|
365
|
+
};
|
|
366
|
+
|
|
367
|
+
// Delete a string at the current position.
|
|
368
|
+
TextOperation.prototype['delete'] = function (n) {
|
|
369
|
+
if (typeof n === 'string') { n = n.length; }
|
|
370
|
+
if (typeof n !== 'number') {
|
|
371
|
+
throw new Error("delete expects an integer or a string");
|
|
372
|
+
}
|
|
373
|
+
if (n === 0) { return this; }
|
|
374
|
+
if (n > 0) { n = -n; }
|
|
375
|
+
this.baseLength -= n;
|
|
376
|
+
if (isDelete(this.ops[this.ops.length-1])) {
|
|
377
|
+
this.ops[this.ops.length-1] += n;
|
|
378
|
+
} else {
|
|
379
|
+
this.ops.push(n);
|
|
380
|
+
}
|
|
381
|
+
return this;
|
|
382
|
+
};
|
|
383
|
+
|
|
384
|
+
// Tests whether this operation has no effect.
|
|
385
|
+
TextOperation.prototype.isNoop = function () {
|
|
386
|
+
return this.ops.length === 0 || (this.ops.length === 1 && isRetain(this.ops[0]));
|
|
387
|
+
};
|
|
388
|
+
|
|
389
|
+
// Pretty printing.
|
|
390
|
+
TextOperation.prototype.toString = function () {
|
|
391
|
+
// map: build a new array by applying a function to every element in an old
|
|
392
|
+
// array.
|
|
393
|
+
var map = Array.prototype.map || function (fn) {
|
|
394
|
+
var arr = this;
|
|
395
|
+
var newArr = [];
|
|
396
|
+
for (var i = 0, l = arr.length; i < l; i++) {
|
|
397
|
+
newArr[i] = fn(arr[i]);
|
|
398
|
+
}
|
|
399
|
+
return newArr;
|
|
400
|
+
};
|
|
401
|
+
return map.call(this.ops, function (op) {
|
|
402
|
+
if (isRetain(op)) {
|
|
403
|
+
return "retain " + op;
|
|
404
|
+
} else if (isInsert(op)) {
|
|
405
|
+
return "insert '" + op + "'";
|
|
406
|
+
} else {
|
|
407
|
+
return "delete " + (-op);
|
|
408
|
+
}
|
|
409
|
+
}).join(', ');
|
|
410
|
+
};
|
|
411
|
+
|
|
412
|
+
// Converts operation into a JSON value.
|
|
413
|
+
TextOperation.prototype.toJSON = function () {
|
|
414
|
+
return this.ops;
|
|
415
|
+
};
|
|
416
|
+
|
|
417
|
+
// Converts a plain JS object into an operation and validates it.
|
|
418
|
+
TextOperation.fromJSON = function (ops) {
|
|
419
|
+
var o = new TextOperation();
|
|
420
|
+
for (var i = 0, l = ops.length; i < l; i++) {
|
|
421
|
+
var op = ops[i];
|
|
422
|
+
if (isRetain(op)) {
|
|
423
|
+
o.retain(op);
|
|
424
|
+
} else if (isInsert(op)) {
|
|
425
|
+
o.insert(op);
|
|
426
|
+
} else if (isDelete(op)) {
|
|
427
|
+
o['delete'](op);
|
|
428
|
+
} else {
|
|
429
|
+
throw new Error("unknown operation: " + JSON.stringify(op));
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
return o;
|
|
433
|
+
};
|
|
434
|
+
|
|
435
|
+
// Apply an operation to a string, returning a new string. Throws an error if
|
|
436
|
+
// there's a mismatch between the input string and the operation.
|
|
437
|
+
TextOperation.prototype.apply = function (str) {
|
|
438
|
+
var operation = this;
|
|
439
|
+
if (str.length !== operation.baseLength) {
|
|
440
|
+
throw new Error("The operation's base length must be equal to the string's length.");
|
|
441
|
+
}
|
|
442
|
+
var newStr = [], j = 0;
|
|
443
|
+
var strIndex = 0;
|
|
444
|
+
var ops = this.ops;
|
|
445
|
+
for (var i = 0, l = ops.length; i < l; i++) {
|
|
446
|
+
var op = ops[i];
|
|
447
|
+
if (isRetain(op)) {
|
|
448
|
+
if (strIndex + op > str.length) {
|
|
449
|
+
throw new Error("Operation can't retain more characters than are left in the string.");
|
|
450
|
+
}
|
|
451
|
+
// Copy skipped part of the old string.
|
|
452
|
+
newStr[j++] = str.slice(strIndex, strIndex + op);
|
|
453
|
+
strIndex += op;
|
|
454
|
+
} else if (isInsert(op)) {
|
|
455
|
+
// Insert string.
|
|
456
|
+
newStr[j++] = op;
|
|
457
|
+
} else { // delete op
|
|
458
|
+
strIndex -= op;
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
if (strIndex !== str.length) {
|
|
462
|
+
throw new Error("The operation didn't operate on the whole string.");
|
|
463
|
+
}
|
|
464
|
+
return newStr.join('');
|
|
465
|
+
};
|
|
466
|
+
|
|
467
|
+
// Computes the inverse of an operation. The inverse of an operation is the
|
|
468
|
+
// operation that reverts the effects of the operation, e.g. when you have an
|
|
469
|
+
// operation 'insert("hello "); skip(6);' then the inverse is 'delete("hello ");
|
|
470
|
+
// skip(6);'. The inverse should be used for implementing undo.
|
|
471
|
+
TextOperation.prototype.invert = function (str) {
|
|
472
|
+
var strIndex = 0;
|
|
473
|
+
var inverse = new TextOperation();
|
|
474
|
+
var ops = this.ops;
|
|
475
|
+
for (var i = 0, l = ops.length; i < l; i++) {
|
|
476
|
+
var op = ops[i];
|
|
477
|
+
if (isRetain(op)) {
|
|
478
|
+
inverse.retain(op);
|
|
479
|
+
strIndex += op;
|
|
480
|
+
} else if (isInsert(op)) {
|
|
481
|
+
inverse['delete'](op.length);
|
|
482
|
+
} else { // delete op
|
|
483
|
+
inverse.insert(str.slice(strIndex, strIndex - op));
|
|
484
|
+
strIndex -= op;
|
|
485
|
+
}
|
|
486
|
+
}
|
|
487
|
+
return inverse;
|
|
488
|
+
};
|
|
489
|
+
|
|
490
|
+
// Compose merges two consecutive operations into one operation, that
|
|
491
|
+
// preserves the changes of both. Or, in other words, for each input string S
|
|
492
|
+
// and a pair of consecutive operations A and B,
|
|
493
|
+
// apply(apply(S, A), B) = apply(S, compose(A, B)) must hold.
|
|
494
|
+
TextOperation.prototype.compose = function (operation2) {
|
|
495
|
+
var operation1 = this;
|
|
496
|
+
if (operation1.targetLength !== operation2.baseLength) {
|
|
497
|
+
throw new Error("The base length of the second operation has to be the target length of the first operation");
|
|
498
|
+
}
|
|
499
|
+
|
|
500
|
+
var operation = new TextOperation(); // the combined operation
|
|
501
|
+
var ops1 = operation1.ops, ops2 = operation2.ops; // for fast access
|
|
502
|
+
var i1 = 0, i2 = 0; // current index into ops1 respectively ops2
|
|
503
|
+
var op1 = ops1[i1++], op2 = ops2[i2++]; // current ops
|
|
504
|
+
while (true) {
|
|
505
|
+
// Dispatch on the type of op1 and op2
|
|
506
|
+
if (typeof op1 === 'undefined' && typeof op2 === 'undefined') {
|
|
507
|
+
// end condition: both ops1 and ops2 have been processed
|
|
508
|
+
break;
|
|
509
|
+
}
|
|
510
|
+
|
|
511
|
+
if (isDelete(op1)) {
|
|
512
|
+
operation['delete'](op1);
|
|
513
|
+
op1 = ops1[i1++];
|
|
514
|
+
continue;
|
|
515
|
+
}
|
|
516
|
+
if (isInsert(op2)) {
|
|
517
|
+
operation.insert(op2);
|
|
518
|
+
op2 = ops2[i2++];
|
|
519
|
+
continue;
|
|
520
|
+
}
|
|
521
|
+
|
|
522
|
+
if (typeof op1 === 'undefined') {
|
|
523
|
+
throw new Error("Cannot compose operations: first operation is too short.");
|
|
524
|
+
}
|
|
525
|
+
if (typeof op2 === 'undefined') {
|
|
526
|
+
throw new Error("Cannot compose operations: first operation is too long.");
|
|
527
|
+
}
|
|
528
|
+
|
|
529
|
+
if (isRetain(op1) && isRetain(op2)) {
|
|
530
|
+
if (op1 > op2) {
|
|
531
|
+
operation.retain(op2);
|
|
532
|
+
op1 = op1 - op2;
|
|
533
|
+
op2 = ops2[i2++];
|
|
534
|
+
} else if (op1 === op2) {
|
|
535
|
+
operation.retain(op1);
|
|
536
|
+
op1 = ops1[i1++];
|
|
537
|
+
op2 = ops2[i2++];
|
|
538
|
+
} else {
|
|
539
|
+
operation.retain(op1);
|
|
540
|
+
op2 = op2 - op1;
|
|
541
|
+
op1 = ops1[i1++];
|
|
542
|
+
}
|
|
543
|
+
} else if (isInsert(op1) && isDelete(op2)) {
|
|
544
|
+
if (op1.length > -op2) {
|
|
545
|
+
op1 = op1.slice(-op2);
|
|
546
|
+
op2 = ops2[i2++];
|
|
547
|
+
} else if (op1.length === -op2) {
|
|
548
|
+
op1 = ops1[i1++];
|
|
549
|
+
op2 = ops2[i2++];
|
|
550
|
+
} else {
|
|
551
|
+
op2 = op2 + op1.length;
|
|
552
|
+
op1 = ops1[i1++];
|
|
553
|
+
}
|
|
554
|
+
} else if (isInsert(op1) && isRetain(op2)) {
|
|
555
|
+
if (op1.length > op2) {
|
|
556
|
+
operation.insert(op1.slice(0, op2));
|
|
557
|
+
op1 = op1.slice(op2);
|
|
558
|
+
op2 = ops2[i2++];
|
|
559
|
+
} else if (op1.length === op2) {
|
|
560
|
+
operation.insert(op1);
|
|
561
|
+
op1 = ops1[i1++];
|
|
562
|
+
op2 = ops2[i2++];
|
|
563
|
+
} else {
|
|
564
|
+
operation.insert(op1);
|
|
565
|
+
op2 = op2 - op1.length;
|
|
566
|
+
op1 = ops1[i1++];
|
|
567
|
+
}
|
|
568
|
+
} else if (isRetain(op1) && isDelete(op2)) {
|
|
569
|
+
if (op1 > -op2) {
|
|
570
|
+
operation['delete'](op2);
|
|
571
|
+
op1 = op1 + op2;
|
|
572
|
+
op2 = ops2[i2++];
|
|
573
|
+
} else if (op1 === -op2) {
|
|
574
|
+
operation['delete'](op2);
|
|
575
|
+
op1 = ops1[i1++];
|
|
576
|
+
op2 = ops2[i2++];
|
|
577
|
+
} else {
|
|
578
|
+
operation['delete'](op1);
|
|
579
|
+
op2 = op2 + op1;
|
|
580
|
+
op1 = ops1[i1++];
|
|
581
|
+
}
|
|
582
|
+
} else {
|
|
583
|
+
throw new Error(
|
|
584
|
+
"This shouldn't happen: op1: " +
|
|
585
|
+
JSON.stringify(op1) + ", op2: " +
|
|
586
|
+
JSON.stringify(op2)
|
|
587
|
+
);
|
|
588
|
+
}
|
|
589
|
+
}
|
|
590
|
+
return operation;
|
|
591
|
+
};
|
|
592
|
+
|
|
593
|
+
function getSimpleOp (operation, fn) {
|
|
594
|
+
var ops = operation.ops;
|
|
595
|
+
var isRetain = TextOperation.isRetain;
|
|
596
|
+
switch (ops.length) {
|
|
597
|
+
case 1:
|
|
598
|
+
return ops[0];
|
|
599
|
+
case 2:
|
|
600
|
+
return isRetain(ops[0]) ? ops[1] : (isRetain(ops[1]) ? ops[0] : null);
|
|
601
|
+
case 3:
|
|
602
|
+
if (isRetain(ops[0]) && isRetain(ops[2])) { return ops[1]; }
|
|
603
|
+
}
|
|
604
|
+
return null;
|
|
605
|
+
}
|
|
606
|
+
|
|
607
|
+
function getStartIndex (operation) {
|
|
608
|
+
if (isRetain(operation.ops[0])) { return operation.ops[0]; }
|
|
609
|
+
return 0;
|
|
610
|
+
}
|
|
611
|
+
|
|
612
|
+
// When you use ctrl-z to undo your latest changes, you expect the program not
|
|
613
|
+
// to undo every single keystroke but to undo your last sentence you wrote at
|
|
614
|
+
// a stretch or the deletion you did by holding the backspace key down. This
|
|
615
|
+
// This can be implemented by composing operations on the undo stack. This
|
|
616
|
+
// method can help decide whether two operations should be composed. It
|
|
617
|
+
// returns true if the operations are consecutive insert operations or both
|
|
618
|
+
// operations delete text at the same position. You may want to include other
|
|
619
|
+
// factors like the time since the last change in your decision.
|
|
620
|
+
TextOperation.prototype.shouldBeComposedWith = function (other) {
|
|
621
|
+
if (this.isNoop() || other.isNoop()) { return true; }
|
|
622
|
+
|
|
623
|
+
var startA = getStartIndex(this), startB = getStartIndex(other);
|
|
624
|
+
var simpleA = getSimpleOp(this), simpleB = getSimpleOp(other);
|
|
625
|
+
if (!simpleA || !simpleB) { return false; }
|
|
626
|
+
|
|
627
|
+
if (isInsert(simpleA) && isInsert(simpleB)) {
|
|
628
|
+
return startA + simpleA.length === startB;
|
|
629
|
+
}
|
|
630
|
+
|
|
631
|
+
if (isDelete(simpleA) && isDelete(simpleB)) {
|
|
632
|
+
// there are two possibilities to delete: with backspace and with the
|
|
633
|
+
// delete key.
|
|
634
|
+
return (startB - simpleB === startA) || startA === startB;
|
|
635
|
+
}
|
|
636
|
+
|
|
637
|
+
return false;
|
|
638
|
+
};
|
|
639
|
+
|
|
640
|
+
// Decides whether two operations should be composed with each other
|
|
641
|
+
// if they were inverted, that is
|
|
642
|
+
// `shouldBeComposedWith(a, b) = shouldBeComposedWithInverted(b^{-1}, a^{-1})`.
|
|
643
|
+
TextOperation.prototype.shouldBeComposedWithInverted = function (other) {
|
|
644
|
+
if (this.isNoop() || other.isNoop()) { return true; }
|
|
645
|
+
|
|
646
|
+
var startA = getStartIndex(this), startB = getStartIndex(other);
|
|
647
|
+
var simpleA = getSimpleOp(this), simpleB = getSimpleOp(other);
|
|
648
|
+
if (!simpleA || !simpleB) { return false; }
|
|
649
|
+
|
|
650
|
+
if (isInsert(simpleA) && isInsert(simpleB)) {
|
|
651
|
+
return startA + simpleA.length === startB || startA === startB;
|
|
652
|
+
}
|
|
653
|
+
|
|
654
|
+
if (isDelete(simpleA) && isDelete(simpleB)) {
|
|
655
|
+
return startB - simpleB === startA;
|
|
656
|
+
}
|
|
657
|
+
|
|
658
|
+
return false;
|
|
659
|
+
};
|
|
660
|
+
|
|
661
|
+
// Transform takes two operations A and B that happened concurrently and
|
|
662
|
+
// produces two operations A' and B' (in an array) such that
|
|
663
|
+
// `apply(apply(S, A), B') = apply(apply(S, B), A')`. This function is the
|
|
664
|
+
// heart of OT.
|
|
665
|
+
TextOperation.transform = function (operation1, operation2) {
|
|
666
|
+
if (operation1.baseLength !== operation2.baseLength) {
|
|
667
|
+
throw new Error("Both operations have to have the same base length");
|
|
668
|
+
}
|
|
669
|
+
|
|
670
|
+
var operation1prime = new TextOperation();
|
|
671
|
+
var operation2prime = new TextOperation();
|
|
672
|
+
var ops1 = operation1.ops, ops2 = operation2.ops;
|
|
673
|
+
var i1 = 0, i2 = 0;
|
|
674
|
+
var op1 = ops1[i1++], op2 = ops2[i2++];
|
|
675
|
+
while (true) {
|
|
676
|
+
// At every iteration of the loop, the imaginary cursor that both
|
|
677
|
+
// operation1 and operation2 have that operates on the input string must
|
|
678
|
+
// have the same position in the input string.
|
|
679
|
+
|
|
680
|
+
if (typeof op1 === 'undefined' && typeof op2 === 'undefined') {
|
|
681
|
+
// end condition: both ops1 and ops2 have been processed
|
|
682
|
+
break;
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
// next two cases: one or both ops are insert ops
|
|
686
|
+
// => insert the string in the corresponding prime operation, skip it in
|
|
687
|
+
// the other one. If both op1 and op2 are insert ops, prefer op1.
|
|
688
|
+
if (isInsert(op1)) {
|
|
689
|
+
operation1prime.insert(op1);
|
|
690
|
+
operation2prime.retain(op1.length);
|
|
691
|
+
op1 = ops1[i1++];
|
|
692
|
+
continue;
|
|
693
|
+
}
|
|
694
|
+
if (isInsert(op2)) {
|
|
695
|
+
operation1prime.retain(op2.length);
|
|
696
|
+
operation2prime.insert(op2);
|
|
697
|
+
op2 = ops2[i2++];
|
|
698
|
+
continue;
|
|
699
|
+
}
|
|
700
|
+
|
|
701
|
+
if (typeof op1 === 'undefined') {
|
|
702
|
+
throw new Error("Cannot compose operations: first operation is too short.");
|
|
703
|
+
}
|
|
704
|
+
if (typeof op2 === 'undefined') {
|
|
705
|
+
throw new Error("Cannot compose operations: first operation is too long.");
|
|
706
|
+
}
|
|
707
|
+
|
|
708
|
+
var minl;
|
|
709
|
+
if (isRetain(op1) && isRetain(op2)) {
|
|
710
|
+
// Simple case: retain/retain
|
|
711
|
+
if (op1 > op2) {
|
|
712
|
+
minl = op2;
|
|
713
|
+
op1 = op1 - op2;
|
|
714
|
+
op2 = ops2[i2++];
|
|
715
|
+
} else if (op1 === op2) {
|
|
716
|
+
minl = op2;
|
|
717
|
+
op1 = ops1[i1++];
|
|
718
|
+
op2 = ops2[i2++];
|
|
719
|
+
} else {
|
|
720
|
+
minl = op1;
|
|
721
|
+
op2 = op2 - op1;
|
|
722
|
+
op1 = ops1[i1++];
|
|
723
|
+
}
|
|
724
|
+
operation1prime.retain(minl);
|
|
725
|
+
operation2prime.retain(minl);
|
|
726
|
+
} else if (isDelete(op1) && isDelete(op2)) {
|
|
727
|
+
// Both operations delete the same string at the same position. We don't
|
|
728
|
+
// need to produce any operations, we just skip over the delete ops and
|
|
729
|
+
// handle the case that one operation deletes more than the other.
|
|
730
|
+
if (-op1 > -op2) {
|
|
731
|
+
op1 = op1 - op2;
|
|
732
|
+
op2 = ops2[i2++];
|
|
733
|
+
} else if (op1 === op2) {
|
|
734
|
+
op1 = ops1[i1++];
|
|
735
|
+
op2 = ops2[i2++];
|
|
736
|
+
} else {
|
|
737
|
+
op2 = op2 - op1;
|
|
738
|
+
op1 = ops1[i1++];
|
|
739
|
+
}
|
|
740
|
+
// next two cases: delete/retain and retain/delete
|
|
741
|
+
} else if (isDelete(op1) && isRetain(op2)) {
|
|
742
|
+
if (-op1 > op2) {
|
|
743
|
+
minl = op2;
|
|
744
|
+
op1 = op1 + op2;
|
|
745
|
+
op2 = ops2[i2++];
|
|
746
|
+
} else if (-op1 === op2) {
|
|
747
|
+
minl = op2;
|
|
748
|
+
op1 = ops1[i1++];
|
|
749
|
+
op2 = ops2[i2++];
|
|
750
|
+
} else {
|
|
751
|
+
minl = -op1;
|
|
752
|
+
op2 = op2 + op1;
|
|
753
|
+
op1 = ops1[i1++];
|
|
754
|
+
}
|
|
755
|
+
operation1prime['delete'](minl);
|
|
756
|
+
} else if (isRetain(op1) && isDelete(op2)) {
|
|
757
|
+
if (op1 > -op2) {
|
|
758
|
+
minl = -op2;
|
|
759
|
+
op1 = op1 + op2;
|
|
760
|
+
op2 = ops2[i2++];
|
|
761
|
+
} else if (op1 === -op2) {
|
|
762
|
+
minl = op1;
|
|
763
|
+
op1 = ops1[i1++];
|
|
764
|
+
op2 = ops2[i2++];
|
|
765
|
+
} else {
|
|
766
|
+
minl = op1;
|
|
767
|
+
op2 = op2 + op1;
|
|
768
|
+
op1 = ops1[i1++];
|
|
769
|
+
}
|
|
770
|
+
operation2prime['delete'](minl);
|
|
771
|
+
} else {
|
|
772
|
+
throw new Error("The two operations aren't compatible");
|
|
773
|
+
}
|
|
774
|
+
}
|
|
775
|
+
|
|
776
|
+
return [operation1prime, operation2prime];
|
|
777
|
+
};
|
|
778
|
+
|
|
779
|
+
return TextOperation;
|
|
780
|
+
|
|
781
|
+
}());
|
|
782
|
+
|
|
783
|
+
// Export for CommonJS
|
|
784
|
+
if (true) {
|
|
785
|
+
module.exports = ot.TextOperation;
|
|
786
|
+
}
|
|
787
|
+
|
|
788
|
+
/***/ },
|
|
789
|
+
/* 5 */
|
|
790
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
791
|
+
|
|
792
|
+
if (typeof ot === 'undefined') {
|
|
793
|
+
// Export for browsers
|
|
794
|
+
var ot = {};
|
|
795
|
+
}
|
|
796
|
+
|
|
797
|
+
ot.SimpleTextOperation = (function (global) {
|
|
798
|
+
|
|
799
|
+
var TextOperation = global.ot ? global.ot.TextOperation : __webpack_require__(4);
|
|
800
|
+
|
|
801
|
+
function SimpleTextOperation () {}
|
|
802
|
+
|
|
803
|
+
|
|
804
|
+
// Insert the string `str` at the zero-based `position` in the document.
|
|
805
|
+
function Insert (str, position) {
|
|
806
|
+
if (!this || this.constructor !== SimpleTextOperation) {
|
|
807
|
+
// => function was called without 'new'
|
|
808
|
+
return new Insert(str, position);
|
|
809
|
+
}
|
|
810
|
+
this.str = str;
|
|
811
|
+
this.position = position;
|
|
812
|
+
}
|
|
813
|
+
|
|
814
|
+
Insert.prototype = new SimpleTextOperation();
|
|
815
|
+
SimpleTextOperation.Insert = Insert;
|
|
816
|
+
|
|
817
|
+
Insert.prototype.toString = function () {
|
|
818
|
+
return 'Insert(' + JSON.stringify(this.str) + ', ' + this.position + ')';
|
|
819
|
+
};
|
|
820
|
+
|
|
821
|
+
Insert.prototype.equals = function (other) {
|
|
822
|
+
return other instanceof Insert &&
|
|
823
|
+
this.str === other.str &&
|
|
824
|
+
this.position === other.position;
|
|
825
|
+
};
|
|
826
|
+
|
|
827
|
+
Insert.prototype.apply = function (doc) {
|
|
828
|
+
return doc.slice(0, this.position) + this.str + doc.slice(this.position);
|
|
829
|
+
};
|
|
830
|
+
|
|
831
|
+
|
|
832
|
+
// Delete `count` many characters at the zero-based `position` in the document.
|
|
833
|
+
function Delete (count, position) {
|
|
834
|
+
if (!this || this.constructor !== SimpleTextOperation) {
|
|
835
|
+
return new Delete(count, position);
|
|
836
|
+
}
|
|
837
|
+
this.count = count;
|
|
838
|
+
this.position = position;
|
|
839
|
+
}
|
|
840
|
+
|
|
841
|
+
Delete.prototype = new SimpleTextOperation();
|
|
842
|
+
SimpleTextOperation.Delete = Delete;
|
|
843
|
+
|
|
844
|
+
Delete.prototype.toString = function () {
|
|
845
|
+
return 'Delete(' + this.count + ', ' + this.position + ')';
|
|
846
|
+
};
|
|
847
|
+
|
|
848
|
+
Delete.prototype.equals = function (other) {
|
|
849
|
+
return other instanceof Delete &&
|
|
850
|
+
this.count === other.count &&
|
|
851
|
+
this.position === other.position;
|
|
852
|
+
};
|
|
853
|
+
|
|
854
|
+
Delete.prototype.apply = function (doc) {
|
|
855
|
+
return doc.slice(0, this.position) + doc.slice(this.position + this.count);
|
|
856
|
+
};
|
|
857
|
+
|
|
858
|
+
|
|
859
|
+
// An operation that does nothing. This is needed for the result of the
|
|
860
|
+
// transformation of two deletions of the same character.
|
|
861
|
+
function Noop () {
|
|
862
|
+
if (!this || this.constructor !== SimpleTextOperation) { return new Noop(); }
|
|
863
|
+
}
|
|
864
|
+
|
|
865
|
+
Noop.prototype = new SimpleTextOperation();
|
|
866
|
+
SimpleTextOperation.Noop = Noop;
|
|
867
|
+
|
|
868
|
+
Noop.prototype.toString = function () {
|
|
869
|
+
return 'Noop()';
|
|
870
|
+
};
|
|
871
|
+
|
|
872
|
+
Noop.prototype.equals = function (other) { return other instanceof Noop; };
|
|
873
|
+
|
|
874
|
+
Noop.prototype.apply = function (doc) { return doc; };
|
|
875
|
+
|
|
876
|
+
var noop = new Noop();
|
|
877
|
+
|
|
878
|
+
|
|
879
|
+
SimpleTextOperation.transform = function (a, b) {
|
|
880
|
+
if (a instanceof Noop || b instanceof Noop) { return [a, b]; }
|
|
881
|
+
|
|
882
|
+
if (a instanceof Insert && b instanceof Insert) {
|
|
883
|
+
if (a.position < b.position || (a.position === b.position && a.str < b.str)) {
|
|
884
|
+
return [a, new Insert(b.str, b.position + a.str.length)];
|
|
885
|
+
}
|
|
886
|
+
if (a.position > b.position || (a.position === b.position && a.str > b.str)) {
|
|
887
|
+
return [new Insert(a.str, a.position + b.str.length), b];
|
|
888
|
+
}
|
|
889
|
+
return [noop, noop];
|
|
890
|
+
}
|
|
891
|
+
|
|
892
|
+
if (a instanceof Insert && b instanceof Delete) {
|
|
893
|
+
if (a.position <= b.position) {
|
|
894
|
+
return [a, new Delete(b.count, b.position + a.str.length)];
|
|
895
|
+
}
|
|
896
|
+
if (a.position >= b.position + b.count) {
|
|
897
|
+
return [new Insert(a.str, a.position - b.count), b];
|
|
898
|
+
}
|
|
899
|
+
// Here, we have to delete the inserted string of operation a.
|
|
900
|
+
// That doesn't preserve the intention of operation a, but it's the only
|
|
901
|
+
// thing we can do to get a valid transform function.
|
|
902
|
+
return [noop, new Delete(b.count + a.str.length, b.position)];
|
|
903
|
+
}
|
|
904
|
+
|
|
905
|
+
if (a instanceof Delete && b instanceof Insert) {
|
|
906
|
+
if (a.position >= b.position) {
|
|
907
|
+
return [new Delete(a.count, a.position + b.str.length), b];
|
|
908
|
+
}
|
|
909
|
+
if (a.position + a.count <= b.position) {
|
|
910
|
+
return [a, new Insert(b.str, b.position - a.count)];
|
|
911
|
+
}
|
|
912
|
+
// Same problem as above. We have to delete the string that was inserted
|
|
913
|
+
// in operation b.
|
|
914
|
+
return [new Delete(a.count + b.str.length, a.position), noop];
|
|
915
|
+
}
|
|
916
|
+
|
|
917
|
+
if (a instanceof Delete && b instanceof Delete) {
|
|
918
|
+
if (a.position === b.position) {
|
|
919
|
+
if (a.count === b.count) {
|
|
920
|
+
return [noop, noop];
|
|
921
|
+
} else if (a.count < b.count) {
|
|
922
|
+
return [noop, new Delete(b.count - a.count, b.position)];
|
|
923
|
+
}
|
|
924
|
+
return [new Delete(a.count - b.count, a.position), noop];
|
|
925
|
+
}
|
|
926
|
+
if (a.position < b.position) {
|
|
927
|
+
if (a.position + a.count <= b.position) {
|
|
928
|
+
return [a, new Delete(b.count, b.position - a.count)];
|
|
929
|
+
}
|
|
930
|
+
if (a.position + a.count >= b.position + b.count) {
|
|
931
|
+
return [new Delete(a.count - b.count, a.position), noop];
|
|
932
|
+
}
|
|
933
|
+
return [
|
|
934
|
+
new Delete(b.position - a.position, a.position),
|
|
935
|
+
new Delete(b.position + b.count - (a.position + a.count), a.position)
|
|
936
|
+
];
|
|
937
|
+
}
|
|
938
|
+
if (a.position > b.position) {
|
|
939
|
+
if (a.position >= b.position + b.count) {
|
|
940
|
+
return [new Delete(a.count, a.position - b.count), b];
|
|
941
|
+
}
|
|
942
|
+
if (a.position + a.count <= b.position + b.count) {
|
|
943
|
+
return [noop, new Delete(b.count - a.count, b.position)];
|
|
944
|
+
}
|
|
945
|
+
return [
|
|
946
|
+
new Delete(a.position + a.count - (b.position + b.count), b.position),
|
|
947
|
+
new Delete(a.position - b.position, b.position)
|
|
948
|
+
];
|
|
949
|
+
}
|
|
950
|
+
}
|
|
951
|
+
};
|
|
952
|
+
|
|
953
|
+
// Convert a normal, composable `TextOperation` into an array of
|
|
954
|
+
// `SimpleTextOperation`s.
|
|
955
|
+
SimpleTextOperation.fromTextOperation = function (operation) {
|
|
956
|
+
var simpleOperations = [];
|
|
957
|
+
var index = 0;
|
|
958
|
+
for (var i = 0; i < operation.ops.length; i++) {
|
|
959
|
+
var op = operation.ops[i];
|
|
960
|
+
if (TextOperation.isRetain(op)) {
|
|
961
|
+
index += op;
|
|
962
|
+
} else if (TextOperation.isInsert(op)) {
|
|
963
|
+
simpleOperations.push(new Insert(op, index));
|
|
964
|
+
index += op.length;
|
|
965
|
+
} else {
|
|
966
|
+
simpleOperations.push(new Delete(Math.abs(op), index));
|
|
967
|
+
}
|
|
968
|
+
}
|
|
969
|
+
return simpleOperations;
|
|
970
|
+
};
|
|
971
|
+
|
|
972
|
+
|
|
973
|
+
return SimpleTextOperation;
|
|
974
|
+
})(this);
|
|
975
|
+
|
|
976
|
+
// Export for CommonJS
|
|
977
|
+
if (true) {
|
|
978
|
+
module.exports = ot.SimpleTextOperation;
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
/***/ },
|
|
982
|
+
/* 6 */
|
|
983
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
984
|
+
|
|
985
|
+
// translation of https://github.com/djspiewak/cccp/blob/master/agent/src/main/scala/com/codecommit/cccp/agent/state.scala
|
|
986
|
+
|
|
987
|
+
if (typeof ot === 'undefined') {
|
|
988
|
+
var ot = {};
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
ot.Client = (function (global) {
|
|
992
|
+
'use strict';
|
|
993
|
+
|
|
994
|
+
// Client constructor
|
|
995
|
+
function Client (revision) {
|
|
996
|
+
this.revision = revision; // the next expected revision number
|
|
997
|
+
this.state = synchronized_; // start state
|
|
998
|
+
}
|
|
999
|
+
|
|
1000
|
+
Client.prototype.setState = function (state) {
|
|
1001
|
+
this.state = state;
|
|
1002
|
+
};
|
|
1003
|
+
|
|
1004
|
+
// Call this method when the user changes the document.
|
|
1005
|
+
Client.prototype.applyClient = function (operation) {
|
|
1006
|
+
this.setState(this.state.applyClient(this, operation));
|
|
1007
|
+
};
|
|
1008
|
+
|
|
1009
|
+
// Call this method with a new operation from the server
|
|
1010
|
+
Client.prototype.applyServer = function (operation) {
|
|
1011
|
+
this.revision++;
|
|
1012
|
+
this.setState(this.state.applyServer(this, operation));
|
|
1013
|
+
};
|
|
1014
|
+
|
|
1015
|
+
Client.prototype.serverAck = function () {
|
|
1016
|
+
this.revision++;
|
|
1017
|
+
this.setState(this.state.serverAck(this));
|
|
1018
|
+
};
|
|
1019
|
+
|
|
1020
|
+
Client.prototype.serverReconnect = function () {
|
|
1021
|
+
if (typeof this.state.resend === 'function') { this.state.resend(this); }
|
|
1022
|
+
};
|
|
1023
|
+
|
|
1024
|
+
// Transforms a selection from the latest known server state to the current
|
|
1025
|
+
// client state. For example, if we get from the server the information that
|
|
1026
|
+
// another user's cursor is at position 3, but the server hasn't yet received
|
|
1027
|
+
// our newest operation, an insertion of 5 characters at the beginning of the
|
|
1028
|
+
// document, the correct position of the other user's cursor in our current
|
|
1029
|
+
// document is 8.
|
|
1030
|
+
Client.prototype.transformSelection = function (selection) {
|
|
1031
|
+
return this.state.transformSelection(selection);
|
|
1032
|
+
};
|
|
1033
|
+
|
|
1034
|
+
// Override this method.
|
|
1035
|
+
Client.prototype.sendOperation = function (revision, operation) {
|
|
1036
|
+
throw new Error("sendOperation must be defined in child class");
|
|
1037
|
+
};
|
|
1038
|
+
|
|
1039
|
+
// Override this method.
|
|
1040
|
+
Client.prototype.applyOperation = function (operation) {
|
|
1041
|
+
throw new Error("applyOperation must be defined in child class");
|
|
1042
|
+
};
|
|
1043
|
+
|
|
1044
|
+
|
|
1045
|
+
// In the 'Synchronized' state, there is no pending operation that the client
|
|
1046
|
+
// has sent to the server.
|
|
1047
|
+
function Synchronized () {}
|
|
1048
|
+
Client.Synchronized = Synchronized;
|
|
1049
|
+
|
|
1050
|
+
Synchronized.prototype.applyClient = function (client, operation) {
|
|
1051
|
+
// When the user makes an edit, send the operation to the server and
|
|
1052
|
+
// switch to the 'AwaitingConfirm' state
|
|
1053
|
+
client.sendOperation(client.revision, operation);
|
|
1054
|
+
return new AwaitingConfirm(operation);
|
|
1055
|
+
};
|
|
1056
|
+
|
|
1057
|
+
Synchronized.prototype.applyServer = function (client, operation) {
|
|
1058
|
+
// When we receive a new operation from the server, the operation can be
|
|
1059
|
+
// simply applied to the current document
|
|
1060
|
+
client.applyOperation(operation);
|
|
1061
|
+
return this;
|
|
1062
|
+
};
|
|
1063
|
+
|
|
1064
|
+
Synchronized.prototype.serverAck = function (client) {
|
|
1065
|
+
throw new Error("There is no pending operation.");
|
|
1066
|
+
};
|
|
1067
|
+
|
|
1068
|
+
// Nothing to do because the latest server state and client state are the same.
|
|
1069
|
+
Synchronized.prototype.transformSelection = function (x) { return x; };
|
|
1070
|
+
|
|
1071
|
+
// Singleton
|
|
1072
|
+
var synchronized_ = new Synchronized();
|
|
1073
|
+
|
|
1074
|
+
|
|
1075
|
+
// In the 'AwaitingConfirm' state, there's one operation the client has sent
|
|
1076
|
+
// to the server and is still waiting for an acknowledgement.
|
|
1077
|
+
function AwaitingConfirm (outstanding) {
|
|
1078
|
+
// Save the pending operation
|
|
1079
|
+
this.outstanding = outstanding;
|
|
1080
|
+
}
|
|
1081
|
+
Client.AwaitingConfirm = AwaitingConfirm;
|
|
1082
|
+
|
|
1083
|
+
AwaitingConfirm.prototype.applyClient = function (client, operation) {
|
|
1084
|
+
// When the user makes an edit, don't send the operation immediately,
|
|
1085
|
+
// instead switch to 'AwaitingWithBuffer' state
|
|
1086
|
+
return new AwaitingWithBuffer(this.outstanding, operation);
|
|
1087
|
+
};
|
|
1088
|
+
|
|
1089
|
+
AwaitingConfirm.prototype.applyServer = function (client, operation) {
|
|
1090
|
+
// This is another client's operation. Visualization:
|
|
1091
|
+
//
|
|
1092
|
+
// /\
|
|
1093
|
+
// this.outstanding / \ operation
|
|
1094
|
+
// / \
|
|
1095
|
+
// \ /
|
|
1096
|
+
// pair[1] \ / pair[0] (new outstanding)
|
|
1097
|
+
// (can be applied \/
|
|
1098
|
+
// to the client's
|
|
1099
|
+
// current document)
|
|
1100
|
+
var pair = operation.constructor.transform(this.outstanding, operation);
|
|
1101
|
+
client.applyOperation(pair[1]);
|
|
1102
|
+
return new AwaitingConfirm(pair[0]);
|
|
1103
|
+
};
|
|
1104
|
+
|
|
1105
|
+
AwaitingConfirm.prototype.serverAck = function (client) {
|
|
1106
|
+
// The client's operation has been acknowledged
|
|
1107
|
+
// => switch to synchronized state
|
|
1108
|
+
return synchronized_;
|
|
1109
|
+
};
|
|
1110
|
+
|
|
1111
|
+
AwaitingConfirm.prototype.transformSelection = function (selection) {
|
|
1112
|
+
return selection.transform(this.outstanding);
|
|
1113
|
+
};
|
|
1114
|
+
|
|
1115
|
+
AwaitingConfirm.prototype.resend = function (client) {
|
|
1116
|
+
// The confirm didn't come because the client was disconnected.
|
|
1117
|
+
// Now that it has reconnected, we resend the outstanding operation.
|
|
1118
|
+
client.sendOperation(client.revision, this.outstanding);
|
|
1119
|
+
};
|
|
1120
|
+
|
|
1121
|
+
|
|
1122
|
+
// In the 'AwaitingWithBuffer' state, the client is waiting for an operation
|
|
1123
|
+
// to be acknowledged by the server while buffering the edits the user makes
|
|
1124
|
+
function AwaitingWithBuffer (outstanding, buffer) {
|
|
1125
|
+
// Save the pending operation and the user's edits since then
|
|
1126
|
+
this.outstanding = outstanding;
|
|
1127
|
+
this.buffer = buffer;
|
|
1128
|
+
}
|
|
1129
|
+
Client.AwaitingWithBuffer = AwaitingWithBuffer;
|
|
1130
|
+
|
|
1131
|
+
AwaitingWithBuffer.prototype.applyClient = function (client, operation) {
|
|
1132
|
+
// Compose the user's changes onto the buffer
|
|
1133
|
+
var newBuffer = this.buffer.compose(operation);
|
|
1134
|
+
return new AwaitingWithBuffer(this.outstanding, newBuffer);
|
|
1135
|
+
};
|
|
1136
|
+
|
|
1137
|
+
AwaitingWithBuffer.prototype.applyServer = function (client, operation) {
|
|
1138
|
+
// Operation comes from another client
|
|
1139
|
+
//
|
|
1140
|
+
// /\
|
|
1141
|
+
// this.outstanding / \ operation
|
|
1142
|
+
// / \
|
|
1143
|
+
// /\ /
|
|
1144
|
+
// this.buffer / \* / pair1[0] (new outstanding)
|
|
1145
|
+
// / \/
|
|
1146
|
+
// \ /
|
|
1147
|
+
// pair2[1] \ / pair2[0] (new buffer)
|
|
1148
|
+
// the transformed \/
|
|
1149
|
+
// operation -- can
|
|
1150
|
+
// be applied to the
|
|
1151
|
+
// client's current
|
|
1152
|
+
// document
|
|
1153
|
+
//
|
|
1154
|
+
// * pair1[1]
|
|
1155
|
+
var transform = operation.constructor.transform;
|
|
1156
|
+
var pair1 = transform(this.outstanding, operation);
|
|
1157
|
+
var pair2 = transform(this.buffer, pair1[1]);
|
|
1158
|
+
client.applyOperation(pair2[1]);
|
|
1159
|
+
return new AwaitingWithBuffer(pair1[0], pair2[0]);
|
|
1160
|
+
};
|
|
1161
|
+
|
|
1162
|
+
AwaitingWithBuffer.prototype.serverAck = function (client) {
|
|
1163
|
+
// The pending operation has been acknowledged
|
|
1164
|
+
// => send buffer
|
|
1165
|
+
client.sendOperation(client.revision, this.buffer);
|
|
1166
|
+
return new AwaitingConfirm(this.buffer);
|
|
1167
|
+
};
|
|
1168
|
+
|
|
1169
|
+
AwaitingWithBuffer.prototype.transformSelection = function (selection) {
|
|
1170
|
+
return selection.transform(this.outstanding).transform(this.buffer);
|
|
1171
|
+
};
|
|
1172
|
+
|
|
1173
|
+
AwaitingWithBuffer.prototype.resend = function (client) {
|
|
1174
|
+
// The confirm didn't come because the client was disconnected.
|
|
1175
|
+
// Now that it has reconnected, we resend the outstanding operation.
|
|
1176
|
+
client.sendOperation(client.revision, this.outstanding);
|
|
1177
|
+
};
|
|
1178
|
+
|
|
1179
|
+
|
|
1180
|
+
return Client;
|
|
1181
|
+
|
|
1182
|
+
}(this));
|
|
1183
|
+
|
|
1184
|
+
if (true) {
|
|
1185
|
+
module.exports = ot.Client;
|
|
1186
|
+
}
|
|
1187
|
+
|
|
1188
|
+
|
|
1189
|
+
/***/ },
|
|
1190
|
+
/* 7 */
|
|
1191
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
1192
|
+
|
|
1193
|
+
if (typeof ot === 'undefined') {
|
|
1194
|
+
var ot = {};
|
|
1195
|
+
}
|
|
1196
|
+
|
|
1197
|
+
ot.Server = (function (global) {
|
|
1198
|
+
'use strict';
|
|
1199
|
+
|
|
1200
|
+
// Constructor. Takes the current document as a string and optionally the array
|
|
1201
|
+
// of all operations.
|
|
1202
|
+
function Server (document, operations) {
|
|
1203
|
+
this.document = document;
|
|
1204
|
+
this.operations = operations || [];
|
|
1205
|
+
}
|
|
1206
|
+
|
|
1207
|
+
// Call this method whenever you receive an operation from a client.
|
|
1208
|
+
Server.prototype.receiveOperation = function (revision, operation) {
|
|
1209
|
+
if (revision < 0 || this.operations.length < revision) {
|
|
1210
|
+
throw new Error("operation revision not in history");
|
|
1211
|
+
}
|
|
1212
|
+
// Find all operations that the client didn't know of when it sent the
|
|
1213
|
+
// operation ...
|
|
1214
|
+
var concurrentOperations = this.operations.slice(revision);
|
|
1215
|
+
|
|
1216
|
+
// ... and transform the operation against all these operations ...
|
|
1217
|
+
var transform = operation.constructor.transform;
|
|
1218
|
+
for (var i = 0; i < concurrentOperations.length; i++) {
|
|
1219
|
+
operation = transform(operation, concurrentOperations[i])[0];
|
|
1220
|
+
}
|
|
1221
|
+
|
|
1222
|
+
// ... and apply that on the document.
|
|
1223
|
+
this.document = operation.apply(this.document);
|
|
1224
|
+
// Store operation in history.
|
|
1225
|
+
this.operations.push(operation);
|
|
1226
|
+
|
|
1227
|
+
// It's the caller's responsibility to send the operation to all connected
|
|
1228
|
+
// clients and an acknowledgement to the creator.
|
|
1229
|
+
return operation;
|
|
1230
|
+
};
|
|
1231
|
+
|
|
1232
|
+
return Server;
|
|
1233
|
+
|
|
1234
|
+
}(this));
|
|
1235
|
+
|
|
1236
|
+
if (true) {
|
|
1237
|
+
module.exports = ot.Server;
|
|
1238
|
+
}
|
|
1239
|
+
|
|
1240
|
+
/***/ },
|
|
1241
|
+
/* 8 */
|
|
1242
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
1243
|
+
|
|
1244
|
+
if (typeof ot === 'undefined') {
|
|
1245
|
+
// Export for browsers
|
|
1246
|
+
var ot = {};
|
|
1247
|
+
}
|
|
1248
|
+
|
|
1249
|
+
ot.Selection = (function (global) {
|
|
1250
|
+
'use strict';
|
|
1251
|
+
|
|
1252
|
+
var TextOperation = global.ot ? global.ot.TextOperation : __webpack_require__(4);
|
|
1253
|
+
|
|
1254
|
+
// Range has `anchor` and `head` properties, which are zero-based indices into
|
|
1255
|
+
// the document. The `anchor` is the side of the selection that stays fixed,
|
|
1256
|
+
// `head` is the side of the selection where the cursor is. When both are
|
|
1257
|
+
// equal, the range represents a cursor.
|
|
1258
|
+
function Range (anchor, head) {
|
|
1259
|
+
this.anchor = anchor;
|
|
1260
|
+
this.head = head;
|
|
1261
|
+
}
|
|
1262
|
+
|
|
1263
|
+
Range.fromJSON = function (obj) {
|
|
1264
|
+
return new Range(obj.anchor, obj.head);
|
|
1265
|
+
};
|
|
1266
|
+
|
|
1267
|
+
Range.prototype.equals = function (other) {
|
|
1268
|
+
return this.anchor === other.anchor && this.head === other.head;
|
|
1269
|
+
};
|
|
1270
|
+
|
|
1271
|
+
Range.prototype.isEmpty = function () {
|
|
1272
|
+
return this.anchor === this.head;
|
|
1273
|
+
};
|
|
1274
|
+
|
|
1275
|
+
Range.prototype.transform = function (other) {
|
|
1276
|
+
function transformIndex (index) {
|
|
1277
|
+
var newIndex = index;
|
|
1278
|
+
var ops = other.ops;
|
|
1279
|
+
for (var i = 0, l = other.ops.length; i < l; i++) {
|
|
1280
|
+
if (TextOperation.isRetain(ops[i])) {
|
|
1281
|
+
index -= ops[i];
|
|
1282
|
+
} else if (TextOperation.isInsert(ops[i])) {
|
|
1283
|
+
newIndex += ops[i].length;
|
|
1284
|
+
} else {
|
|
1285
|
+
newIndex -= Math.min(index, -ops[i]);
|
|
1286
|
+
index += ops[i];
|
|
1287
|
+
}
|
|
1288
|
+
if (index < 0) { break; }
|
|
1289
|
+
}
|
|
1290
|
+
return newIndex;
|
|
1291
|
+
}
|
|
1292
|
+
|
|
1293
|
+
var newAnchor = transformIndex(this.anchor);
|
|
1294
|
+
if (this.anchor === this.head) {
|
|
1295
|
+
return new Range(newAnchor, newAnchor);
|
|
1296
|
+
}
|
|
1297
|
+
return new Range(newAnchor, transformIndex(this.head));
|
|
1298
|
+
};
|
|
1299
|
+
|
|
1300
|
+
// A selection is basically an array of ranges. Every range represents a real
|
|
1301
|
+
// selection or a cursor in the document (when the start position equals the
|
|
1302
|
+
// end position of the range). The array must not be empty.
|
|
1303
|
+
function Selection (ranges) {
|
|
1304
|
+
this.ranges = ranges || [];
|
|
1305
|
+
}
|
|
1306
|
+
|
|
1307
|
+
Selection.Range = Range;
|
|
1308
|
+
|
|
1309
|
+
// Convenience method for creating selections only containing a single cursor
|
|
1310
|
+
// and no real selection range.
|
|
1311
|
+
Selection.createCursor = function (position) {
|
|
1312
|
+
return new Selection([new Range(position, position)]);
|
|
1313
|
+
};
|
|
1314
|
+
|
|
1315
|
+
Selection.fromJSON = function (obj) {
|
|
1316
|
+
var objRanges = obj.ranges || obj;
|
|
1317
|
+
for (var i = 0, ranges = []; i < objRanges.length; i++) {
|
|
1318
|
+
ranges[i] = Range.fromJSON(objRanges[i]);
|
|
1319
|
+
}
|
|
1320
|
+
return new Selection(ranges);
|
|
1321
|
+
};
|
|
1322
|
+
|
|
1323
|
+
Selection.prototype.equals = function (other) {
|
|
1324
|
+
if (this.position !== other.position) { return false; }
|
|
1325
|
+
if (this.ranges.length !== other.ranges.length) { return false; }
|
|
1326
|
+
// FIXME: Sort ranges before comparing them?
|
|
1327
|
+
for (var i = 0; i < this.ranges.length; i++) {
|
|
1328
|
+
if (!this.ranges[i].equals(other.ranges[i])) { return false; }
|
|
1329
|
+
}
|
|
1330
|
+
return true;
|
|
1331
|
+
};
|
|
1332
|
+
|
|
1333
|
+
Selection.prototype.somethingSelected = function () {
|
|
1334
|
+
for (var i = 0; i < this.ranges.length; i++) {
|
|
1335
|
+
if (!this.ranges[i].isEmpty()) { return true; }
|
|
1336
|
+
}
|
|
1337
|
+
return false;
|
|
1338
|
+
};
|
|
1339
|
+
|
|
1340
|
+
// Return the more current selection information.
|
|
1341
|
+
Selection.prototype.compose = function (other) {
|
|
1342
|
+
return other;
|
|
1343
|
+
};
|
|
1344
|
+
|
|
1345
|
+
// Update the selection with respect to an operation.
|
|
1346
|
+
Selection.prototype.transform = function (other) {
|
|
1347
|
+
for (var i = 0, newRanges = []; i < this.ranges.length; i++) {
|
|
1348
|
+
newRanges[i] = this.ranges[i].transform(other);
|
|
1349
|
+
}
|
|
1350
|
+
return new Selection(newRanges);
|
|
1351
|
+
};
|
|
1352
|
+
|
|
1353
|
+
return Selection;
|
|
1354
|
+
|
|
1355
|
+
}(this));
|
|
1356
|
+
|
|
1357
|
+
// Export for CommonJS
|
|
1358
|
+
if (true) {
|
|
1359
|
+
module.exports = ot.Selection;
|
|
1360
|
+
}
|
|
1361
|
+
|
|
1362
|
+
|
|
1363
|
+
/***/ },
|
|
1364
|
+
/* 9 */
|
|
1365
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
1366
|
+
|
|
1367
|
+
'use strict';
|
|
1368
|
+
|
|
1369
|
+
var EventEmitter = __webpack_require__(10).EventEmitter;
|
|
1370
|
+
var TextOperation = __webpack_require__(4);
|
|
1371
|
+
var WrappedOperation = __webpack_require__(11);
|
|
1372
|
+
var Server = __webpack_require__(7);
|
|
1373
|
+
var Selection = __webpack_require__(8);
|
|
1374
|
+
var util = __webpack_require__(12);
|
|
1375
|
+
|
|
1376
|
+
function EditorSocketIOServer (document, operations, docId, mayWrite) {
|
|
1377
|
+
EventEmitter.call(this);
|
|
1378
|
+
Server.call(this, document, operations);
|
|
1379
|
+
this.users = {};
|
|
1380
|
+
this.docId = docId;
|
|
1381
|
+
this.mayWrite = mayWrite || function (_, cb) { cb(true); };
|
|
1382
|
+
}
|
|
1383
|
+
|
|
1384
|
+
util.inherits(EditorSocketIOServer, Server);
|
|
1385
|
+
extend(EditorSocketIOServer.prototype, EventEmitter.prototype);
|
|
1386
|
+
|
|
1387
|
+
function extend (target, source) {
|
|
1388
|
+
for (var key in source) {
|
|
1389
|
+
if (source.hasOwnProperty(key)) {
|
|
1390
|
+
target[key] = source[key];
|
|
1391
|
+
}
|
|
1392
|
+
}
|
|
1393
|
+
}
|
|
1394
|
+
|
|
1395
|
+
EditorSocketIOServer.prototype.addClient = function (socket) {
|
|
1396
|
+
var self = this;
|
|
1397
|
+
socket
|
|
1398
|
+
.join(this.docId)
|
|
1399
|
+
.emit('doc', {
|
|
1400
|
+
str: this.document,
|
|
1401
|
+
revision: this.operations.length,
|
|
1402
|
+
clients: this.users
|
|
1403
|
+
})
|
|
1404
|
+
.on('operation', function (revision, operation, selection) {
|
|
1405
|
+
self.mayWrite(socket, function (mayWrite) {
|
|
1406
|
+
if (!mayWrite) {
|
|
1407
|
+
console.log("User doesn't have the right to edit.");
|
|
1408
|
+
return;
|
|
1409
|
+
}
|
|
1410
|
+
self.onOperation(socket, revision, operation, selection);
|
|
1411
|
+
});
|
|
1412
|
+
})
|
|
1413
|
+
.on('selection', function (obj) {
|
|
1414
|
+
self.mayWrite(socket, function (mayWrite) {
|
|
1415
|
+
if (!mayWrite) {
|
|
1416
|
+
console.log("User doesn't have the right to edit.");
|
|
1417
|
+
return;
|
|
1418
|
+
}
|
|
1419
|
+
self.updateSelection(socket, obj && Selection.fromJSON(obj));
|
|
1420
|
+
});
|
|
1421
|
+
})
|
|
1422
|
+
.on('disconnect', function () {
|
|
1423
|
+
console.log("Disconnect");
|
|
1424
|
+
socket.leave(self.docId);
|
|
1425
|
+
self.onDisconnect(socket);
|
|
1426
|
+
if (socket.manager.sockets.clients(self.docId).length === 0) {
|
|
1427
|
+
self.emit('empty-room');
|
|
1428
|
+
}
|
|
1429
|
+
});
|
|
1430
|
+
};
|
|
1431
|
+
|
|
1432
|
+
EditorSocketIOServer.prototype.onOperation = function (socket, revision, operation, selection) {
|
|
1433
|
+
var wrapped;
|
|
1434
|
+
try {
|
|
1435
|
+
wrapped = new WrappedOperation(
|
|
1436
|
+
TextOperation.fromJSON(operation),
|
|
1437
|
+
selection && Selection.fromJSON(selection)
|
|
1438
|
+
);
|
|
1439
|
+
} catch (exc) {
|
|
1440
|
+
console.error("Invalid operation received: " + exc);
|
|
1441
|
+
return;
|
|
1442
|
+
}
|
|
1443
|
+
|
|
1444
|
+
try {
|
|
1445
|
+
var clientId = socket.id;
|
|
1446
|
+
var wrappedPrime = this.receiveOperation(revision, wrapped);
|
|
1447
|
+
console.log("new operation: " + wrapped);
|
|
1448
|
+
this.getClient(clientId).selection = wrappedPrime.meta;
|
|
1449
|
+
socket.emit('ack');
|
|
1450
|
+
socket.broadcast['in'](this.docId).emit(
|
|
1451
|
+
'operation', clientId,
|
|
1452
|
+
wrappedPrime.wrapped.toJSON(), wrappedPrime.meta
|
|
1453
|
+
);
|
|
1454
|
+
} catch (exc) {
|
|
1455
|
+
console.error(exc);
|
|
1456
|
+
}
|
|
1457
|
+
};
|
|
1458
|
+
|
|
1459
|
+
EditorSocketIOServer.prototype.updateSelection = function (socket, selection) {
|
|
1460
|
+
var clientId = socket.id;
|
|
1461
|
+
if (selection) {
|
|
1462
|
+
this.getClient(clientId).selection = selection;
|
|
1463
|
+
} else {
|
|
1464
|
+
delete this.getClient(clientId).selection;
|
|
1465
|
+
}
|
|
1466
|
+
socket.broadcast['in'](this.docId).emit('selection', clientId, selection);
|
|
1467
|
+
};
|
|
1468
|
+
|
|
1469
|
+
EditorSocketIOServer.prototype.setName = function (socket, name) {
|
|
1470
|
+
var clientId = socket.id;
|
|
1471
|
+
this.getClient(clientId).name = name;
|
|
1472
|
+
socket.broadcast['in'](this.docId).emit('set_name', clientId, name);
|
|
1473
|
+
};
|
|
1474
|
+
|
|
1475
|
+
EditorSocketIOServer.prototype.getClient = function (clientId) {
|
|
1476
|
+
return this.users[clientId] || (this.users[clientId] = {});
|
|
1477
|
+
};
|
|
1478
|
+
|
|
1479
|
+
EditorSocketIOServer.prototype.onDisconnect = function (socket) {
|
|
1480
|
+
var clientId = socket.id;
|
|
1481
|
+
delete this.users[clientId];
|
|
1482
|
+
socket.broadcast['in'](this.docId).emit('client_left', clientId);
|
|
1483
|
+
};
|
|
1484
|
+
|
|
1485
|
+
module.exports = EditorSocketIOServer;
|
|
1486
|
+
|
|
1487
|
+
/***/ },
|
|
1488
|
+
/* 10 */
|
|
1489
|
+
/***/ function(module, exports) {
|
|
1490
|
+
|
|
1491
|
+
// Copyright Joyent, Inc. and other Node contributors.
|
|
1492
|
+
//
|
|
1493
|
+
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
1494
|
+
// copy of this software and associated documentation files (the
|
|
1495
|
+
// "Software"), to deal in the Software without restriction, including
|
|
1496
|
+
// without limitation the rights to use, copy, modify, merge, publish,
|
|
1497
|
+
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
1498
|
+
// persons to whom the Software is furnished to do so, subject to the
|
|
1499
|
+
// following conditions:
|
|
1500
|
+
//
|
|
1501
|
+
// The above copyright notice and this permission notice shall be included
|
|
1502
|
+
// in all copies or substantial portions of the Software.
|
|
1503
|
+
//
|
|
1504
|
+
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
1505
|
+
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
1506
|
+
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
1507
|
+
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
1508
|
+
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
1509
|
+
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
1510
|
+
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
1511
|
+
|
|
1512
|
+
function EventEmitter() {
|
|
1513
|
+
this._events = this._events || {};
|
|
1514
|
+
this._maxListeners = this._maxListeners || undefined;
|
|
1515
|
+
}
|
|
1516
|
+
module.exports = EventEmitter;
|
|
1517
|
+
|
|
1518
|
+
// Backwards-compat with node 0.10.x
|
|
1519
|
+
EventEmitter.EventEmitter = EventEmitter;
|
|
1520
|
+
|
|
1521
|
+
EventEmitter.prototype._events = undefined;
|
|
1522
|
+
EventEmitter.prototype._maxListeners = undefined;
|
|
1523
|
+
|
|
1524
|
+
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
1525
|
+
// added to it. This is a useful default which helps finding memory leaks.
|
|
1526
|
+
EventEmitter.defaultMaxListeners = 10;
|
|
1527
|
+
|
|
1528
|
+
// Obviously not all Emitters should be limited to 10. This function allows
|
|
1529
|
+
// that to be increased. Set to zero for unlimited.
|
|
1530
|
+
EventEmitter.prototype.setMaxListeners = function(n) {
|
|
1531
|
+
if (!isNumber(n) || n < 0 || isNaN(n))
|
|
1532
|
+
throw TypeError('n must be a positive number');
|
|
1533
|
+
this._maxListeners = n;
|
|
1534
|
+
return this;
|
|
1535
|
+
};
|
|
1536
|
+
|
|
1537
|
+
EventEmitter.prototype.emit = function(type) {
|
|
1538
|
+
var er, handler, len, args, i, listeners;
|
|
1539
|
+
|
|
1540
|
+
if (!this._events)
|
|
1541
|
+
this._events = {};
|
|
1542
|
+
|
|
1543
|
+
// If there is no 'error' event listener then throw.
|
|
1544
|
+
if (type === 'error') {
|
|
1545
|
+
if (!this._events.error ||
|
|
1546
|
+
(isObject(this._events.error) && !this._events.error.length)) {
|
|
1547
|
+
er = arguments[1];
|
|
1548
|
+
if (er instanceof Error) {
|
|
1549
|
+
throw er; // Unhandled 'error' event
|
|
1550
|
+
} else {
|
|
1551
|
+
// At least give some kind of context to the user
|
|
1552
|
+
var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
|
|
1553
|
+
err.context = er;
|
|
1554
|
+
throw err;
|
|
1555
|
+
}
|
|
1556
|
+
}
|
|
1557
|
+
}
|
|
1558
|
+
|
|
1559
|
+
handler = this._events[type];
|
|
1560
|
+
|
|
1561
|
+
if (isUndefined(handler))
|
|
1562
|
+
return false;
|
|
1563
|
+
|
|
1564
|
+
if (isFunction(handler)) {
|
|
1565
|
+
switch (arguments.length) {
|
|
1566
|
+
// fast cases
|
|
1567
|
+
case 1:
|
|
1568
|
+
handler.call(this);
|
|
1569
|
+
break;
|
|
1570
|
+
case 2:
|
|
1571
|
+
handler.call(this, arguments[1]);
|
|
1572
|
+
break;
|
|
1573
|
+
case 3:
|
|
1574
|
+
handler.call(this, arguments[1], arguments[2]);
|
|
1575
|
+
break;
|
|
1576
|
+
// slower
|
|
1577
|
+
default:
|
|
1578
|
+
args = Array.prototype.slice.call(arguments, 1);
|
|
1579
|
+
handler.apply(this, args);
|
|
1580
|
+
}
|
|
1581
|
+
} else if (isObject(handler)) {
|
|
1582
|
+
args = Array.prototype.slice.call(arguments, 1);
|
|
1583
|
+
listeners = handler.slice();
|
|
1584
|
+
len = listeners.length;
|
|
1585
|
+
for (i = 0; i < len; i++)
|
|
1586
|
+
listeners[i].apply(this, args);
|
|
1587
|
+
}
|
|
1588
|
+
|
|
1589
|
+
return true;
|
|
1590
|
+
};
|
|
1591
|
+
|
|
1592
|
+
EventEmitter.prototype.addListener = function(type, listener) {
|
|
1593
|
+
var m;
|
|
1594
|
+
|
|
1595
|
+
if (!isFunction(listener))
|
|
1596
|
+
throw TypeError('listener must be a function');
|
|
1597
|
+
|
|
1598
|
+
if (!this._events)
|
|
1599
|
+
this._events = {};
|
|
1600
|
+
|
|
1601
|
+
// To avoid recursion in the case that type === "newListener"! Before
|
|
1602
|
+
// adding it to the listeners, first emit "newListener".
|
|
1603
|
+
if (this._events.newListener)
|
|
1604
|
+
this.emit('newListener', type,
|
|
1605
|
+
isFunction(listener.listener) ?
|
|
1606
|
+
listener.listener : listener);
|
|
1607
|
+
|
|
1608
|
+
if (!this._events[type])
|
|
1609
|
+
// Optimize the case of one listener. Don't need the extra array object.
|
|
1610
|
+
this._events[type] = listener;
|
|
1611
|
+
else if (isObject(this._events[type]))
|
|
1612
|
+
// If we've already got an array, just append.
|
|
1613
|
+
this._events[type].push(listener);
|
|
1614
|
+
else
|
|
1615
|
+
// Adding the second element, need to change to array.
|
|
1616
|
+
this._events[type] = [this._events[type], listener];
|
|
1617
|
+
|
|
1618
|
+
// Check for listener leak
|
|
1619
|
+
if (isObject(this._events[type]) && !this._events[type].warned) {
|
|
1620
|
+
if (!isUndefined(this._maxListeners)) {
|
|
1621
|
+
m = this._maxListeners;
|
|
1622
|
+
} else {
|
|
1623
|
+
m = EventEmitter.defaultMaxListeners;
|
|
1624
|
+
}
|
|
1625
|
+
|
|
1626
|
+
if (m && m > 0 && this._events[type].length > m) {
|
|
1627
|
+
this._events[type].warned = true;
|
|
1628
|
+
console.error('(node) warning: possible EventEmitter memory ' +
|
|
1629
|
+
'leak detected. %d listeners added. ' +
|
|
1630
|
+
'Use emitter.setMaxListeners() to increase limit.',
|
|
1631
|
+
this._events[type].length);
|
|
1632
|
+
if (typeof console.trace === 'function') {
|
|
1633
|
+
// not supported in IE 10
|
|
1634
|
+
console.trace();
|
|
1635
|
+
}
|
|
1636
|
+
}
|
|
1637
|
+
}
|
|
1638
|
+
|
|
1639
|
+
return this;
|
|
1640
|
+
};
|
|
1641
|
+
|
|
1642
|
+
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
1643
|
+
|
|
1644
|
+
EventEmitter.prototype.once = function(type, listener) {
|
|
1645
|
+
if (!isFunction(listener))
|
|
1646
|
+
throw TypeError('listener must be a function');
|
|
1647
|
+
|
|
1648
|
+
var fired = false;
|
|
1649
|
+
|
|
1650
|
+
function g() {
|
|
1651
|
+
this.removeListener(type, g);
|
|
1652
|
+
|
|
1653
|
+
if (!fired) {
|
|
1654
|
+
fired = true;
|
|
1655
|
+
listener.apply(this, arguments);
|
|
1656
|
+
}
|
|
1657
|
+
}
|
|
1658
|
+
|
|
1659
|
+
g.listener = listener;
|
|
1660
|
+
this.on(type, g);
|
|
1661
|
+
|
|
1662
|
+
return this;
|
|
1663
|
+
};
|
|
1664
|
+
|
|
1665
|
+
// emits a 'removeListener' event iff the listener was removed
|
|
1666
|
+
EventEmitter.prototype.removeListener = function(type, listener) {
|
|
1667
|
+
var list, position, length, i;
|
|
1668
|
+
|
|
1669
|
+
if (!isFunction(listener))
|
|
1670
|
+
throw TypeError('listener must be a function');
|
|
1671
|
+
|
|
1672
|
+
if (!this._events || !this._events[type])
|
|
1673
|
+
return this;
|
|
1674
|
+
|
|
1675
|
+
list = this._events[type];
|
|
1676
|
+
length = list.length;
|
|
1677
|
+
position = -1;
|
|
1678
|
+
|
|
1679
|
+
if (list === listener ||
|
|
1680
|
+
(isFunction(list.listener) && list.listener === listener)) {
|
|
1681
|
+
delete this._events[type];
|
|
1682
|
+
if (this._events.removeListener)
|
|
1683
|
+
this.emit('removeListener', type, listener);
|
|
1684
|
+
|
|
1685
|
+
} else if (isObject(list)) {
|
|
1686
|
+
for (i = length; i-- > 0;) {
|
|
1687
|
+
if (list[i] === listener ||
|
|
1688
|
+
(list[i].listener && list[i].listener === listener)) {
|
|
1689
|
+
position = i;
|
|
1690
|
+
break;
|
|
1691
|
+
}
|
|
1692
|
+
}
|
|
1693
|
+
|
|
1694
|
+
if (position < 0)
|
|
1695
|
+
return this;
|
|
1696
|
+
|
|
1697
|
+
if (list.length === 1) {
|
|
1698
|
+
list.length = 0;
|
|
1699
|
+
delete this._events[type];
|
|
1700
|
+
} else {
|
|
1701
|
+
list.splice(position, 1);
|
|
1702
|
+
}
|
|
1703
|
+
|
|
1704
|
+
if (this._events.removeListener)
|
|
1705
|
+
this.emit('removeListener', type, listener);
|
|
1706
|
+
}
|
|
1707
|
+
|
|
1708
|
+
return this;
|
|
1709
|
+
};
|
|
1710
|
+
|
|
1711
|
+
EventEmitter.prototype.removeAllListeners = function(type) {
|
|
1712
|
+
var key, listeners;
|
|
1713
|
+
|
|
1714
|
+
if (!this._events)
|
|
1715
|
+
return this;
|
|
1716
|
+
|
|
1717
|
+
// not listening for removeListener, no need to emit
|
|
1718
|
+
if (!this._events.removeListener) {
|
|
1719
|
+
if (arguments.length === 0)
|
|
1720
|
+
this._events = {};
|
|
1721
|
+
else if (this._events[type])
|
|
1722
|
+
delete this._events[type];
|
|
1723
|
+
return this;
|
|
1724
|
+
}
|
|
1725
|
+
|
|
1726
|
+
// emit removeListener for all listeners on all events
|
|
1727
|
+
if (arguments.length === 0) {
|
|
1728
|
+
for (key in this._events) {
|
|
1729
|
+
if (key === 'removeListener') continue;
|
|
1730
|
+
this.removeAllListeners(key);
|
|
1731
|
+
}
|
|
1732
|
+
this.removeAllListeners('removeListener');
|
|
1733
|
+
this._events = {};
|
|
1734
|
+
return this;
|
|
1735
|
+
}
|
|
1736
|
+
|
|
1737
|
+
listeners = this._events[type];
|
|
1738
|
+
|
|
1739
|
+
if (isFunction(listeners)) {
|
|
1740
|
+
this.removeListener(type, listeners);
|
|
1741
|
+
} else if (listeners) {
|
|
1742
|
+
// LIFO order
|
|
1743
|
+
while (listeners.length)
|
|
1744
|
+
this.removeListener(type, listeners[listeners.length - 1]);
|
|
1745
|
+
}
|
|
1746
|
+
delete this._events[type];
|
|
1747
|
+
|
|
1748
|
+
return this;
|
|
1749
|
+
};
|
|
1750
|
+
|
|
1751
|
+
EventEmitter.prototype.listeners = function(type) {
|
|
1752
|
+
var ret;
|
|
1753
|
+
if (!this._events || !this._events[type])
|
|
1754
|
+
ret = [];
|
|
1755
|
+
else if (isFunction(this._events[type]))
|
|
1756
|
+
ret = [this._events[type]];
|
|
1757
|
+
else
|
|
1758
|
+
ret = this._events[type].slice();
|
|
1759
|
+
return ret;
|
|
1760
|
+
};
|
|
1761
|
+
|
|
1762
|
+
EventEmitter.prototype.listenerCount = function(type) {
|
|
1763
|
+
if (this._events) {
|
|
1764
|
+
var evlistener = this._events[type];
|
|
1765
|
+
|
|
1766
|
+
if (isFunction(evlistener))
|
|
1767
|
+
return 1;
|
|
1768
|
+
else if (evlistener)
|
|
1769
|
+
return evlistener.length;
|
|
1770
|
+
}
|
|
1771
|
+
return 0;
|
|
1772
|
+
};
|
|
1773
|
+
|
|
1774
|
+
EventEmitter.listenerCount = function(emitter, type) {
|
|
1775
|
+
return emitter.listenerCount(type);
|
|
1776
|
+
};
|
|
1777
|
+
|
|
1778
|
+
function isFunction(arg) {
|
|
1779
|
+
return typeof arg === 'function';
|
|
1780
|
+
}
|
|
1781
|
+
|
|
1782
|
+
function isNumber(arg) {
|
|
1783
|
+
return typeof arg === 'number';
|
|
1784
|
+
}
|
|
1785
|
+
|
|
1786
|
+
function isObject(arg) {
|
|
1787
|
+
return typeof arg === 'object' && arg !== null;
|
|
1788
|
+
}
|
|
1789
|
+
|
|
1790
|
+
function isUndefined(arg) {
|
|
1791
|
+
return arg === void 0;
|
|
1792
|
+
}
|
|
1793
|
+
|
|
1794
|
+
|
|
1795
|
+
/***/ },
|
|
1796
|
+
/* 11 */
|
|
1797
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
1798
|
+
|
|
1799
|
+
if (typeof ot === 'undefined') {
|
|
1800
|
+
// Export for browsers
|
|
1801
|
+
var ot = {};
|
|
1802
|
+
}
|
|
1803
|
+
|
|
1804
|
+
ot.WrappedOperation = (function (global) {
|
|
1805
|
+
'use strict';
|
|
1806
|
+
|
|
1807
|
+
// A WrappedOperation contains an operation and corresponing metadata.
|
|
1808
|
+
function WrappedOperation (operation, meta) {
|
|
1809
|
+
this.wrapped = operation;
|
|
1810
|
+
this.meta = meta;
|
|
1811
|
+
}
|
|
1812
|
+
|
|
1813
|
+
WrappedOperation.prototype.apply = function () {
|
|
1814
|
+
return this.wrapped.apply.apply(this.wrapped, arguments);
|
|
1815
|
+
};
|
|
1816
|
+
|
|
1817
|
+
WrappedOperation.prototype.invert = function () {
|
|
1818
|
+
var meta = this.meta;
|
|
1819
|
+
return new WrappedOperation(
|
|
1820
|
+
this.wrapped.invert.apply(this.wrapped, arguments),
|
|
1821
|
+
meta && typeof meta === 'object' && typeof meta.invert === 'function' ?
|
|
1822
|
+
meta.invert.apply(meta, arguments) : meta
|
|
1823
|
+
);
|
|
1824
|
+
};
|
|
1825
|
+
|
|
1826
|
+
// Copy all properties from source to target.
|
|
1827
|
+
function copy (source, target) {
|
|
1828
|
+
for (var key in source) {
|
|
1829
|
+
if (source.hasOwnProperty(key)) {
|
|
1830
|
+
target[key] = source[key];
|
|
1831
|
+
}
|
|
1832
|
+
}
|
|
1833
|
+
}
|
|
1834
|
+
|
|
1835
|
+
function composeMeta (a, b) {
|
|
1836
|
+
if (a && typeof a === 'object') {
|
|
1837
|
+
if (typeof a.compose === 'function') { return a.compose(b); }
|
|
1838
|
+
var meta = {};
|
|
1839
|
+
copy(a, meta);
|
|
1840
|
+
copy(b, meta);
|
|
1841
|
+
return meta;
|
|
1842
|
+
}
|
|
1843
|
+
return b;
|
|
1844
|
+
}
|
|
1845
|
+
|
|
1846
|
+
WrappedOperation.prototype.compose = function (other) {
|
|
1847
|
+
return new WrappedOperation(
|
|
1848
|
+
this.wrapped.compose(other.wrapped),
|
|
1849
|
+
composeMeta(this.meta, other.meta)
|
|
1850
|
+
);
|
|
1851
|
+
};
|
|
1852
|
+
|
|
1853
|
+
function transformMeta (meta, operation) {
|
|
1854
|
+
if (meta && typeof meta === 'object') {
|
|
1855
|
+
if (typeof meta.transform === 'function') {
|
|
1856
|
+
return meta.transform(operation);
|
|
1857
|
+
}
|
|
1858
|
+
}
|
|
1859
|
+
return meta;
|
|
1860
|
+
}
|
|
1861
|
+
|
|
1862
|
+
WrappedOperation.transform = function (a, b) {
|
|
1863
|
+
var transform = a.wrapped.constructor.transform;
|
|
1864
|
+
var pair = transform(a.wrapped, b.wrapped);
|
|
1865
|
+
return [
|
|
1866
|
+
new WrappedOperation(pair[0], transformMeta(a.meta, b.wrapped)),
|
|
1867
|
+
new WrappedOperation(pair[1], transformMeta(b.meta, a.wrapped))
|
|
1868
|
+
];
|
|
1869
|
+
};
|
|
1870
|
+
|
|
1871
|
+
return WrappedOperation;
|
|
1872
|
+
|
|
1873
|
+
}(this));
|
|
1874
|
+
|
|
1875
|
+
// Export for CommonJS
|
|
1876
|
+
if (true) {
|
|
1877
|
+
module.exports = ot.WrappedOperation;
|
|
1878
|
+
}
|
|
1879
|
+
|
|
1880
|
+
/***/ },
|
|
1881
|
+
/* 12 */
|
|
1882
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
1883
|
+
|
|
1884
|
+
/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
|
|
1885
|
+
//
|
|
1886
|
+
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
1887
|
+
// copy of this software and associated documentation files (the
|
|
1888
|
+
// "Software"), to deal in the Software without restriction, including
|
|
1889
|
+
// without limitation the rights to use, copy, modify, merge, publish,
|
|
1890
|
+
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
1891
|
+
// persons to whom the Software is furnished to do so, subject to the
|
|
1892
|
+
// following conditions:
|
|
1893
|
+
//
|
|
1894
|
+
// The above copyright notice and this permission notice shall be included
|
|
1895
|
+
// in all copies or substantial portions of the Software.
|
|
1896
|
+
//
|
|
1897
|
+
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
1898
|
+
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
1899
|
+
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
1900
|
+
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
1901
|
+
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
1902
|
+
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
1903
|
+
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
1904
|
+
|
|
1905
|
+
var formatRegExp = /%[sdj%]/g;
|
|
1906
|
+
exports.format = function(f) {
|
|
1907
|
+
if (!isString(f)) {
|
|
1908
|
+
var objects = [];
|
|
1909
|
+
for (var i = 0; i < arguments.length; i++) {
|
|
1910
|
+
objects.push(inspect(arguments[i]));
|
|
1911
|
+
}
|
|
1912
|
+
return objects.join(' ');
|
|
1913
|
+
}
|
|
1914
|
+
|
|
1915
|
+
var i = 1;
|
|
1916
|
+
var args = arguments;
|
|
1917
|
+
var len = args.length;
|
|
1918
|
+
var str = String(f).replace(formatRegExp, function(x) {
|
|
1919
|
+
if (x === '%%') return '%';
|
|
1920
|
+
if (i >= len) return x;
|
|
1921
|
+
switch (x) {
|
|
1922
|
+
case '%s': return String(args[i++]);
|
|
1923
|
+
case '%d': return Number(args[i++]);
|
|
1924
|
+
case '%j':
|
|
1925
|
+
try {
|
|
1926
|
+
return JSON.stringify(args[i++]);
|
|
1927
|
+
} catch (_) {
|
|
1928
|
+
return '[Circular]';
|
|
1929
|
+
}
|
|
1930
|
+
default:
|
|
1931
|
+
return x;
|
|
1932
|
+
}
|
|
1933
|
+
});
|
|
1934
|
+
for (var x = args[i]; i < len; x = args[++i]) {
|
|
1935
|
+
if (isNull(x) || !isObject(x)) {
|
|
1936
|
+
str += ' ' + x;
|
|
1937
|
+
} else {
|
|
1938
|
+
str += ' ' + inspect(x);
|
|
1939
|
+
}
|
|
1940
|
+
}
|
|
1941
|
+
return str;
|
|
1942
|
+
};
|
|
1943
|
+
|
|
1944
|
+
|
|
1945
|
+
// Mark that a method should not be used.
|
|
1946
|
+
// Returns a modified function which warns once by default.
|
|
1947
|
+
// If --no-deprecation is set, then it is a no-op.
|
|
1948
|
+
exports.deprecate = function(fn, msg) {
|
|
1949
|
+
// Allow for deprecating things in the process of starting up.
|
|
1950
|
+
if (isUndefined(global.process)) {
|
|
1951
|
+
return function() {
|
|
1952
|
+
return exports.deprecate(fn, msg).apply(this, arguments);
|
|
1953
|
+
};
|
|
1954
|
+
}
|
|
1955
|
+
|
|
1956
|
+
if (process.noDeprecation === true) {
|
|
1957
|
+
return fn;
|
|
1958
|
+
}
|
|
1959
|
+
|
|
1960
|
+
var warned = false;
|
|
1961
|
+
function deprecated() {
|
|
1962
|
+
if (!warned) {
|
|
1963
|
+
if (process.throwDeprecation) {
|
|
1964
|
+
throw new Error(msg);
|
|
1965
|
+
} else if (process.traceDeprecation) {
|
|
1966
|
+
console.trace(msg);
|
|
1967
|
+
} else {
|
|
1968
|
+
console.error(msg);
|
|
1969
|
+
}
|
|
1970
|
+
warned = true;
|
|
1971
|
+
}
|
|
1972
|
+
return fn.apply(this, arguments);
|
|
1973
|
+
}
|
|
1974
|
+
|
|
1975
|
+
return deprecated;
|
|
1976
|
+
};
|
|
1977
|
+
|
|
1978
|
+
|
|
1979
|
+
var debugs = {};
|
|
1980
|
+
var debugEnviron;
|
|
1981
|
+
exports.debuglog = function(set) {
|
|
1982
|
+
if (isUndefined(debugEnviron))
|
|
1983
|
+
debugEnviron = process.env.NODE_DEBUG || '';
|
|
1984
|
+
set = set.toUpperCase();
|
|
1985
|
+
if (!debugs[set]) {
|
|
1986
|
+
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
|
|
1987
|
+
var pid = process.pid;
|
|
1988
|
+
debugs[set] = function() {
|
|
1989
|
+
var msg = exports.format.apply(exports, arguments);
|
|
1990
|
+
console.error('%s %d: %s', set, pid, msg);
|
|
1991
|
+
};
|
|
1992
|
+
} else {
|
|
1993
|
+
debugs[set] = function() {};
|
|
1994
|
+
}
|
|
1995
|
+
}
|
|
1996
|
+
return debugs[set];
|
|
1997
|
+
};
|
|
1998
|
+
|
|
1999
|
+
|
|
2000
|
+
/**
|
|
2001
|
+
* Echos the value of a value. Trys to print the value out
|
|
2002
|
+
* in the best way possible given the different types.
|
|
2003
|
+
*
|
|
2004
|
+
* @param {Object} obj The object to print out.
|
|
2005
|
+
* @param {Object} opts Optional options object that alters the output.
|
|
2006
|
+
*/
|
|
2007
|
+
/* legacy: obj, showHidden, depth, colors*/
|
|
2008
|
+
function inspect(obj, opts) {
|
|
2009
|
+
// default options
|
|
2010
|
+
var ctx = {
|
|
2011
|
+
seen: [],
|
|
2012
|
+
stylize: stylizeNoColor
|
|
2013
|
+
};
|
|
2014
|
+
// legacy...
|
|
2015
|
+
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
2016
|
+
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
2017
|
+
if (isBoolean(opts)) {
|
|
2018
|
+
// legacy...
|
|
2019
|
+
ctx.showHidden = opts;
|
|
2020
|
+
} else if (opts) {
|
|
2021
|
+
// got an "options" object
|
|
2022
|
+
exports._extend(ctx, opts);
|
|
2023
|
+
}
|
|
2024
|
+
// set default options
|
|
2025
|
+
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
2026
|
+
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
2027
|
+
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
2028
|
+
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
2029
|
+
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
2030
|
+
return formatValue(ctx, obj, ctx.depth);
|
|
2031
|
+
}
|
|
2032
|
+
exports.inspect = inspect;
|
|
2033
|
+
|
|
2034
|
+
|
|
2035
|
+
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
2036
|
+
inspect.colors = {
|
|
2037
|
+
'bold' : [1, 22],
|
|
2038
|
+
'italic' : [3, 23],
|
|
2039
|
+
'underline' : [4, 24],
|
|
2040
|
+
'inverse' : [7, 27],
|
|
2041
|
+
'white' : [37, 39],
|
|
2042
|
+
'grey' : [90, 39],
|
|
2043
|
+
'black' : [30, 39],
|
|
2044
|
+
'blue' : [34, 39],
|
|
2045
|
+
'cyan' : [36, 39],
|
|
2046
|
+
'green' : [32, 39],
|
|
2047
|
+
'magenta' : [35, 39],
|
|
2048
|
+
'red' : [31, 39],
|
|
2049
|
+
'yellow' : [33, 39]
|
|
2050
|
+
};
|
|
2051
|
+
|
|
2052
|
+
// Don't use 'blue' not visible on cmd.exe
|
|
2053
|
+
inspect.styles = {
|
|
2054
|
+
'special': 'cyan',
|
|
2055
|
+
'number': 'yellow',
|
|
2056
|
+
'boolean': 'yellow',
|
|
2057
|
+
'undefined': 'grey',
|
|
2058
|
+
'null': 'bold',
|
|
2059
|
+
'string': 'green',
|
|
2060
|
+
'date': 'magenta',
|
|
2061
|
+
// "name": intentionally not styling
|
|
2062
|
+
'regexp': 'red'
|
|
2063
|
+
};
|
|
2064
|
+
|
|
2065
|
+
|
|
2066
|
+
function stylizeWithColor(str, styleType) {
|
|
2067
|
+
var style = inspect.styles[styleType];
|
|
2068
|
+
|
|
2069
|
+
if (style) {
|
|
2070
|
+
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
2071
|
+
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
2072
|
+
} else {
|
|
2073
|
+
return str;
|
|
2074
|
+
}
|
|
2075
|
+
}
|
|
2076
|
+
|
|
2077
|
+
|
|
2078
|
+
function stylizeNoColor(str, styleType) {
|
|
2079
|
+
return str;
|
|
2080
|
+
}
|
|
2081
|
+
|
|
2082
|
+
|
|
2083
|
+
function arrayToHash(array) {
|
|
2084
|
+
var hash = {};
|
|
2085
|
+
|
|
2086
|
+
array.forEach(function(val, idx) {
|
|
2087
|
+
hash[val] = true;
|
|
2088
|
+
});
|
|
2089
|
+
|
|
2090
|
+
return hash;
|
|
2091
|
+
}
|
|
2092
|
+
|
|
2093
|
+
|
|
2094
|
+
function formatValue(ctx, value, recurseTimes) {
|
|
2095
|
+
// Provide a hook for user-specified inspect functions.
|
|
2096
|
+
// Check that value is an object with an inspect function on it
|
|
2097
|
+
if (ctx.customInspect &&
|
|
2098
|
+
value &&
|
|
2099
|
+
isFunction(value.inspect) &&
|
|
2100
|
+
// Filter out the util module, it's inspect function is special
|
|
2101
|
+
value.inspect !== exports.inspect &&
|
|
2102
|
+
// Also filter out any prototype objects using the circular check.
|
|
2103
|
+
!(value.constructor && value.constructor.prototype === value)) {
|
|
2104
|
+
var ret = value.inspect(recurseTimes, ctx);
|
|
2105
|
+
if (!isString(ret)) {
|
|
2106
|
+
ret = formatValue(ctx, ret, recurseTimes);
|
|
2107
|
+
}
|
|
2108
|
+
return ret;
|
|
2109
|
+
}
|
|
2110
|
+
|
|
2111
|
+
// Primitive types cannot have properties
|
|
2112
|
+
var primitive = formatPrimitive(ctx, value);
|
|
2113
|
+
if (primitive) {
|
|
2114
|
+
return primitive;
|
|
2115
|
+
}
|
|
2116
|
+
|
|
2117
|
+
// Look up the keys of the object.
|
|
2118
|
+
var keys = Object.keys(value);
|
|
2119
|
+
var visibleKeys = arrayToHash(keys);
|
|
2120
|
+
|
|
2121
|
+
if (ctx.showHidden) {
|
|
2122
|
+
keys = Object.getOwnPropertyNames(value);
|
|
2123
|
+
}
|
|
2124
|
+
|
|
2125
|
+
// IE doesn't make error fields non-enumerable
|
|
2126
|
+
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|
2127
|
+
if (isError(value)
|
|
2128
|
+
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
|
2129
|
+
return formatError(value);
|
|
2130
|
+
}
|
|
2131
|
+
|
|
2132
|
+
// Some type of object without properties can be shortcutted.
|
|
2133
|
+
if (keys.length === 0) {
|
|
2134
|
+
if (isFunction(value)) {
|
|
2135
|
+
var name = value.name ? ': ' + value.name : '';
|
|
2136
|
+
return ctx.stylize('[Function' + name + ']', 'special');
|
|
2137
|
+
}
|
|
2138
|
+
if (isRegExp(value)) {
|
|
2139
|
+
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
2140
|
+
}
|
|
2141
|
+
if (isDate(value)) {
|
|
2142
|
+
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
2143
|
+
}
|
|
2144
|
+
if (isError(value)) {
|
|
2145
|
+
return formatError(value);
|
|
2146
|
+
}
|
|
2147
|
+
}
|
|
2148
|
+
|
|
2149
|
+
var base = '', array = false, braces = ['{', '}'];
|
|
2150
|
+
|
|
2151
|
+
// Make Array say that they are Array
|
|
2152
|
+
if (isArray(value)) {
|
|
2153
|
+
array = true;
|
|
2154
|
+
braces = ['[', ']'];
|
|
2155
|
+
}
|
|
2156
|
+
|
|
2157
|
+
// Make functions say that they are functions
|
|
2158
|
+
if (isFunction(value)) {
|
|
2159
|
+
var n = value.name ? ': ' + value.name : '';
|
|
2160
|
+
base = ' [Function' + n + ']';
|
|
2161
|
+
}
|
|
2162
|
+
|
|
2163
|
+
// Make RegExps say that they are RegExps
|
|
2164
|
+
if (isRegExp(value)) {
|
|
2165
|
+
base = ' ' + RegExp.prototype.toString.call(value);
|
|
2166
|
+
}
|
|
2167
|
+
|
|
2168
|
+
// Make dates with properties first say the date
|
|
2169
|
+
if (isDate(value)) {
|
|
2170
|
+
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
2171
|
+
}
|
|
2172
|
+
|
|
2173
|
+
// Make error with message first say the error
|
|
2174
|
+
if (isError(value)) {
|
|
2175
|
+
base = ' ' + formatError(value);
|
|
2176
|
+
}
|
|
2177
|
+
|
|
2178
|
+
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
2179
|
+
return braces[0] + base + braces[1];
|
|
2180
|
+
}
|
|
2181
|
+
|
|
2182
|
+
if (recurseTimes < 0) {
|
|
2183
|
+
if (isRegExp(value)) {
|
|
2184
|
+
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
2185
|
+
} else {
|
|
2186
|
+
return ctx.stylize('[Object]', 'special');
|
|
2187
|
+
}
|
|
2188
|
+
}
|
|
2189
|
+
|
|
2190
|
+
ctx.seen.push(value);
|
|
2191
|
+
|
|
2192
|
+
var output;
|
|
2193
|
+
if (array) {
|
|
2194
|
+
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
2195
|
+
} else {
|
|
2196
|
+
output = keys.map(function(key) {
|
|
2197
|
+
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
2198
|
+
});
|
|
2199
|
+
}
|
|
2200
|
+
|
|
2201
|
+
ctx.seen.pop();
|
|
2202
|
+
|
|
2203
|
+
return reduceToSingleString(output, base, braces);
|
|
2204
|
+
}
|
|
2205
|
+
|
|
2206
|
+
|
|
2207
|
+
function formatPrimitive(ctx, value) {
|
|
2208
|
+
if (isUndefined(value))
|
|
2209
|
+
return ctx.stylize('undefined', 'undefined');
|
|
2210
|
+
if (isString(value)) {
|
|
2211
|
+
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
2212
|
+
.replace(/'/g, "\\'")
|
|
2213
|
+
.replace(/\\"/g, '"') + '\'';
|
|
2214
|
+
return ctx.stylize(simple, 'string');
|
|
2215
|
+
}
|
|
2216
|
+
if (isNumber(value))
|
|
2217
|
+
return ctx.stylize('' + value, 'number');
|
|
2218
|
+
if (isBoolean(value))
|
|
2219
|
+
return ctx.stylize('' + value, 'boolean');
|
|
2220
|
+
// For some reason typeof null is "object", so special case here.
|
|
2221
|
+
if (isNull(value))
|
|
2222
|
+
return ctx.stylize('null', 'null');
|
|
2223
|
+
}
|
|
2224
|
+
|
|
2225
|
+
|
|
2226
|
+
function formatError(value) {
|
|
2227
|
+
return '[' + Error.prototype.toString.call(value) + ']';
|
|
2228
|
+
}
|
|
2229
|
+
|
|
2230
|
+
|
|
2231
|
+
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
2232
|
+
var output = [];
|
|
2233
|
+
for (var i = 0, l = value.length; i < l; ++i) {
|
|
2234
|
+
if (hasOwnProperty(value, String(i))) {
|
|
2235
|
+
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
2236
|
+
String(i), true));
|
|
2237
|
+
} else {
|
|
2238
|
+
output.push('');
|
|
2239
|
+
}
|
|
2240
|
+
}
|
|
2241
|
+
keys.forEach(function(key) {
|
|
2242
|
+
if (!key.match(/^\d+$/)) {
|
|
2243
|
+
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
2244
|
+
key, true));
|
|
2245
|
+
}
|
|
2246
|
+
});
|
|
2247
|
+
return output;
|
|
2248
|
+
}
|
|
2249
|
+
|
|
2250
|
+
|
|
2251
|
+
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
2252
|
+
var name, str, desc;
|
|
2253
|
+
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
2254
|
+
if (desc.get) {
|
|
2255
|
+
if (desc.set) {
|
|
2256
|
+
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
2257
|
+
} else {
|
|
2258
|
+
str = ctx.stylize('[Getter]', 'special');
|
|
2259
|
+
}
|
|
2260
|
+
} else {
|
|
2261
|
+
if (desc.set) {
|
|
2262
|
+
str = ctx.stylize('[Setter]', 'special');
|
|
2263
|
+
}
|
|
2264
|
+
}
|
|
2265
|
+
if (!hasOwnProperty(visibleKeys, key)) {
|
|
2266
|
+
name = '[' + key + ']';
|
|
2267
|
+
}
|
|
2268
|
+
if (!str) {
|
|
2269
|
+
if (ctx.seen.indexOf(desc.value) < 0) {
|
|
2270
|
+
if (isNull(recurseTimes)) {
|
|
2271
|
+
str = formatValue(ctx, desc.value, null);
|
|
2272
|
+
} else {
|
|
2273
|
+
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
2274
|
+
}
|
|
2275
|
+
if (str.indexOf('\n') > -1) {
|
|
2276
|
+
if (array) {
|
|
2277
|
+
str = str.split('\n').map(function(line) {
|
|
2278
|
+
return ' ' + line;
|
|
2279
|
+
}).join('\n').substr(2);
|
|
2280
|
+
} else {
|
|
2281
|
+
str = '\n' + str.split('\n').map(function(line) {
|
|
2282
|
+
return ' ' + line;
|
|
2283
|
+
}).join('\n');
|
|
2284
|
+
}
|
|
2285
|
+
}
|
|
2286
|
+
} else {
|
|
2287
|
+
str = ctx.stylize('[Circular]', 'special');
|
|
2288
|
+
}
|
|
2289
|
+
}
|
|
2290
|
+
if (isUndefined(name)) {
|
|
2291
|
+
if (array && key.match(/^\d+$/)) {
|
|
2292
|
+
return str;
|
|
2293
|
+
}
|
|
2294
|
+
name = JSON.stringify('' + key);
|
|
2295
|
+
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
2296
|
+
name = name.substr(1, name.length - 2);
|
|
2297
|
+
name = ctx.stylize(name, 'name');
|
|
2298
|
+
} else {
|
|
2299
|
+
name = name.replace(/'/g, "\\'")
|
|
2300
|
+
.replace(/\\"/g, '"')
|
|
2301
|
+
.replace(/(^"|"$)/g, "'");
|
|
2302
|
+
name = ctx.stylize(name, 'string');
|
|
2303
|
+
}
|
|
2304
|
+
}
|
|
2305
|
+
|
|
2306
|
+
return name + ': ' + str;
|
|
2307
|
+
}
|
|
2308
|
+
|
|
2309
|
+
|
|
2310
|
+
function reduceToSingleString(output, base, braces) {
|
|
2311
|
+
var numLinesEst = 0;
|
|
2312
|
+
var length = output.reduce(function(prev, cur) {
|
|
2313
|
+
numLinesEst++;
|
|
2314
|
+
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
2315
|
+
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
2316
|
+
}, 0);
|
|
2317
|
+
|
|
2318
|
+
if (length > 60) {
|
|
2319
|
+
return braces[0] +
|
|
2320
|
+
(base === '' ? '' : base + '\n ') +
|
|
2321
|
+
' ' +
|
|
2322
|
+
output.join(',\n ') +
|
|
2323
|
+
' ' +
|
|
2324
|
+
braces[1];
|
|
2325
|
+
}
|
|
2326
|
+
|
|
2327
|
+
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
2328
|
+
}
|
|
2329
|
+
|
|
2330
|
+
|
|
2331
|
+
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
2332
|
+
// because it is fragile and can be easily faked with `Object.create()`.
|
|
2333
|
+
function isArray(ar) {
|
|
2334
|
+
return Array.isArray(ar);
|
|
2335
|
+
}
|
|
2336
|
+
exports.isArray = isArray;
|
|
2337
|
+
|
|
2338
|
+
function isBoolean(arg) {
|
|
2339
|
+
return typeof arg === 'boolean';
|
|
2340
|
+
}
|
|
2341
|
+
exports.isBoolean = isBoolean;
|
|
2342
|
+
|
|
2343
|
+
function isNull(arg) {
|
|
2344
|
+
return arg === null;
|
|
2345
|
+
}
|
|
2346
|
+
exports.isNull = isNull;
|
|
2347
|
+
|
|
2348
|
+
function isNullOrUndefined(arg) {
|
|
2349
|
+
return arg == null;
|
|
2350
|
+
}
|
|
2351
|
+
exports.isNullOrUndefined = isNullOrUndefined;
|
|
2352
|
+
|
|
2353
|
+
function isNumber(arg) {
|
|
2354
|
+
return typeof arg === 'number';
|
|
2355
|
+
}
|
|
2356
|
+
exports.isNumber = isNumber;
|
|
2357
|
+
|
|
2358
|
+
function isString(arg) {
|
|
2359
|
+
return typeof arg === 'string';
|
|
2360
|
+
}
|
|
2361
|
+
exports.isString = isString;
|
|
2362
|
+
|
|
2363
|
+
function isSymbol(arg) {
|
|
2364
|
+
return typeof arg === 'symbol';
|
|
2365
|
+
}
|
|
2366
|
+
exports.isSymbol = isSymbol;
|
|
2367
|
+
|
|
2368
|
+
function isUndefined(arg) {
|
|
2369
|
+
return arg === void 0;
|
|
2370
|
+
}
|
|
2371
|
+
exports.isUndefined = isUndefined;
|
|
2372
|
+
|
|
2373
|
+
function isRegExp(re) {
|
|
2374
|
+
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
2375
|
+
}
|
|
2376
|
+
exports.isRegExp = isRegExp;
|
|
2377
|
+
|
|
2378
|
+
function isObject(arg) {
|
|
2379
|
+
return typeof arg === 'object' && arg !== null;
|
|
2380
|
+
}
|
|
2381
|
+
exports.isObject = isObject;
|
|
2382
|
+
|
|
2383
|
+
function isDate(d) {
|
|
2384
|
+
return isObject(d) && objectToString(d) === '[object Date]';
|
|
2385
|
+
}
|
|
2386
|
+
exports.isDate = isDate;
|
|
2387
|
+
|
|
2388
|
+
function isError(e) {
|
|
2389
|
+
return isObject(e) &&
|
|
2390
|
+
(objectToString(e) === '[object Error]' || e instanceof Error);
|
|
2391
|
+
}
|
|
2392
|
+
exports.isError = isError;
|
|
2393
|
+
|
|
2394
|
+
function isFunction(arg) {
|
|
2395
|
+
return typeof arg === 'function';
|
|
2396
|
+
}
|
|
2397
|
+
exports.isFunction = isFunction;
|
|
2398
|
+
|
|
2399
|
+
function isPrimitive(arg) {
|
|
2400
|
+
return arg === null ||
|
|
2401
|
+
typeof arg === 'boolean' ||
|
|
2402
|
+
typeof arg === 'number' ||
|
|
2403
|
+
typeof arg === 'string' ||
|
|
2404
|
+
typeof arg === 'symbol' || // ES6 symbol
|
|
2405
|
+
typeof arg === 'undefined';
|
|
2406
|
+
}
|
|
2407
|
+
exports.isPrimitive = isPrimitive;
|
|
2408
|
+
|
|
2409
|
+
exports.isBuffer = __webpack_require__(14);
|
|
2410
|
+
|
|
2411
|
+
function objectToString(o) {
|
|
2412
|
+
return Object.prototype.toString.call(o);
|
|
2413
|
+
}
|
|
2414
|
+
|
|
2415
|
+
|
|
2416
|
+
function pad(n) {
|
|
2417
|
+
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
2418
|
+
}
|
|
2419
|
+
|
|
2420
|
+
|
|
2421
|
+
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
2422
|
+
'Oct', 'Nov', 'Dec'];
|
|
2423
|
+
|
|
2424
|
+
// 26 Feb 16:19:34
|
|
2425
|
+
function timestamp() {
|
|
2426
|
+
var d = new Date();
|
|
2427
|
+
var time = [pad(d.getHours()),
|
|
2428
|
+
pad(d.getMinutes()),
|
|
2429
|
+
pad(d.getSeconds())].join(':');
|
|
2430
|
+
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
2431
|
+
}
|
|
2432
|
+
|
|
2433
|
+
|
|
2434
|
+
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
2435
|
+
exports.log = function() {
|
|
2436
|
+
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
2437
|
+
};
|
|
2438
|
+
|
|
2439
|
+
|
|
2440
|
+
/**
|
|
2441
|
+
* Inherit the prototype methods from one constructor into another.
|
|
2442
|
+
*
|
|
2443
|
+
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
2444
|
+
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
2445
|
+
* during bootstrapping this function needs to be rewritten using some native
|
|
2446
|
+
* functions as prototype setup using normal JavaScript does not work as
|
|
2447
|
+
* expected during bootstrapping (see mirror.js in r114903).
|
|
2448
|
+
*
|
|
2449
|
+
* @param {function} ctor Constructor function which needs to inherit the
|
|
2450
|
+
* prototype.
|
|
2451
|
+
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
2452
|
+
*/
|
|
2453
|
+
exports.inherits = __webpack_require__(15);
|
|
2454
|
+
|
|
2455
|
+
exports._extend = function(origin, add) {
|
|
2456
|
+
// Don't do anything if add isn't an object
|
|
2457
|
+
if (!add || !isObject(add)) return origin;
|
|
2458
|
+
|
|
2459
|
+
var keys = Object.keys(add);
|
|
2460
|
+
var i = keys.length;
|
|
2461
|
+
while (i--) {
|
|
2462
|
+
origin[keys[i]] = add[keys[i]];
|
|
2463
|
+
}
|
|
2464
|
+
return origin;
|
|
2465
|
+
};
|
|
2466
|
+
|
|
2467
|
+
function hasOwnProperty(obj, prop) {
|
|
2468
|
+
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
2469
|
+
}
|
|
2470
|
+
|
|
2471
|
+
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(13)))
|
|
2472
|
+
|
|
2473
|
+
/***/ },
|
|
2474
|
+
/* 13 */
|
|
2475
|
+
/***/ function(module, exports) {
|
|
2476
|
+
|
|
2477
|
+
// shim for using process in browser
|
|
2478
|
+
var process = module.exports = {};
|
|
2479
|
+
|
|
2480
|
+
// cached from whatever global is present so that test runners that stub it
|
|
2481
|
+
// don't break things. But we need to wrap it in a try catch in case it is
|
|
2482
|
+
// wrapped in strict mode code which doesn't define any globals. It's inside a
|
|
2483
|
+
// function because try/catches deoptimize in certain engines.
|
|
2484
|
+
|
|
2485
|
+
var cachedSetTimeout;
|
|
2486
|
+
var cachedClearTimeout;
|
|
2487
|
+
|
|
2488
|
+
function defaultSetTimout() {
|
|
2489
|
+
throw new Error('setTimeout has not been defined');
|
|
2490
|
+
}
|
|
2491
|
+
function defaultClearTimeout () {
|
|
2492
|
+
throw new Error('clearTimeout has not been defined');
|
|
2493
|
+
}
|
|
2494
|
+
(function () {
|
|
2495
|
+
try {
|
|
2496
|
+
if (typeof setTimeout === 'function') {
|
|
2497
|
+
cachedSetTimeout = setTimeout;
|
|
2498
|
+
} else {
|
|
2499
|
+
cachedSetTimeout = defaultSetTimout;
|
|
2500
|
+
}
|
|
2501
|
+
} catch (e) {
|
|
2502
|
+
cachedSetTimeout = defaultSetTimout;
|
|
2503
|
+
}
|
|
2504
|
+
try {
|
|
2505
|
+
if (typeof clearTimeout === 'function') {
|
|
2506
|
+
cachedClearTimeout = clearTimeout;
|
|
2507
|
+
} else {
|
|
2508
|
+
cachedClearTimeout = defaultClearTimeout;
|
|
2509
|
+
}
|
|
2510
|
+
} catch (e) {
|
|
2511
|
+
cachedClearTimeout = defaultClearTimeout;
|
|
2512
|
+
}
|
|
2513
|
+
} ())
|
|
2514
|
+
function runTimeout(fun) {
|
|
2515
|
+
if (cachedSetTimeout === setTimeout) {
|
|
2516
|
+
//normal enviroments in sane situations
|
|
2517
|
+
return setTimeout(fun, 0);
|
|
2518
|
+
}
|
|
2519
|
+
// if setTimeout wasn't available but was latter defined
|
|
2520
|
+
if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
|
|
2521
|
+
cachedSetTimeout = setTimeout;
|
|
2522
|
+
return setTimeout(fun, 0);
|
|
2523
|
+
}
|
|
2524
|
+
try {
|
|
2525
|
+
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
2526
|
+
return cachedSetTimeout(fun, 0);
|
|
2527
|
+
} catch(e){
|
|
2528
|
+
try {
|
|
2529
|
+
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
2530
|
+
return cachedSetTimeout.call(null, fun, 0);
|
|
2531
|
+
} catch(e){
|
|
2532
|
+
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
|
|
2533
|
+
return cachedSetTimeout.call(this, fun, 0);
|
|
2534
|
+
}
|
|
2535
|
+
}
|
|
2536
|
+
|
|
2537
|
+
|
|
2538
|
+
}
|
|
2539
|
+
function runClearTimeout(marker) {
|
|
2540
|
+
if (cachedClearTimeout === clearTimeout) {
|
|
2541
|
+
//normal enviroments in sane situations
|
|
2542
|
+
return clearTimeout(marker);
|
|
2543
|
+
}
|
|
2544
|
+
// if clearTimeout wasn't available but was latter defined
|
|
2545
|
+
if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
|
|
2546
|
+
cachedClearTimeout = clearTimeout;
|
|
2547
|
+
return clearTimeout(marker);
|
|
2548
|
+
}
|
|
2549
|
+
try {
|
|
2550
|
+
// when when somebody has screwed with setTimeout but no I.E. maddness
|
|
2551
|
+
return cachedClearTimeout(marker);
|
|
2552
|
+
} catch (e){
|
|
2553
|
+
try {
|
|
2554
|
+
// When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
|
|
2555
|
+
return cachedClearTimeout.call(null, marker);
|
|
2556
|
+
} catch (e){
|
|
2557
|
+
// same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
|
|
2558
|
+
// Some versions of I.E. have different rules for clearTimeout vs setTimeout
|
|
2559
|
+
return cachedClearTimeout.call(this, marker);
|
|
2560
|
+
}
|
|
2561
|
+
}
|
|
2562
|
+
|
|
2563
|
+
|
|
2564
|
+
|
|
2565
|
+
}
|
|
2566
|
+
var queue = [];
|
|
2567
|
+
var draining = false;
|
|
2568
|
+
var currentQueue;
|
|
2569
|
+
var queueIndex = -1;
|
|
2570
|
+
|
|
2571
|
+
function cleanUpNextTick() {
|
|
2572
|
+
if (!draining || !currentQueue) {
|
|
2573
|
+
return;
|
|
2574
|
+
}
|
|
2575
|
+
draining = false;
|
|
2576
|
+
if (currentQueue.length) {
|
|
2577
|
+
queue = currentQueue.concat(queue);
|
|
2578
|
+
} else {
|
|
2579
|
+
queueIndex = -1;
|
|
2580
|
+
}
|
|
2581
|
+
if (queue.length) {
|
|
2582
|
+
drainQueue();
|
|
2583
|
+
}
|
|
2584
|
+
}
|
|
2585
|
+
|
|
2586
|
+
function drainQueue() {
|
|
2587
|
+
if (draining) {
|
|
2588
|
+
return;
|
|
2589
|
+
}
|
|
2590
|
+
var timeout = runTimeout(cleanUpNextTick);
|
|
2591
|
+
draining = true;
|
|
2592
|
+
|
|
2593
|
+
var len = queue.length;
|
|
2594
|
+
while(len) {
|
|
2595
|
+
currentQueue = queue;
|
|
2596
|
+
queue = [];
|
|
2597
|
+
while (++queueIndex < len) {
|
|
2598
|
+
if (currentQueue) {
|
|
2599
|
+
currentQueue[queueIndex].run();
|
|
2600
|
+
}
|
|
2601
|
+
}
|
|
2602
|
+
queueIndex = -1;
|
|
2603
|
+
len = queue.length;
|
|
2604
|
+
}
|
|
2605
|
+
currentQueue = null;
|
|
2606
|
+
draining = false;
|
|
2607
|
+
runClearTimeout(timeout);
|
|
2608
|
+
}
|
|
2609
|
+
|
|
2610
|
+
process.nextTick = function (fun) {
|
|
2611
|
+
var args = new Array(arguments.length - 1);
|
|
2612
|
+
if (arguments.length > 1) {
|
|
2613
|
+
for (var i = 1; i < arguments.length; i++) {
|
|
2614
|
+
args[i - 1] = arguments[i];
|
|
2615
|
+
}
|
|
2616
|
+
}
|
|
2617
|
+
queue.push(new Item(fun, args));
|
|
2618
|
+
if (queue.length === 1 && !draining) {
|
|
2619
|
+
runTimeout(drainQueue);
|
|
2620
|
+
}
|
|
2621
|
+
};
|
|
2622
|
+
|
|
2623
|
+
// v8 likes predictible objects
|
|
2624
|
+
function Item(fun, array) {
|
|
2625
|
+
this.fun = fun;
|
|
2626
|
+
this.array = array;
|
|
2627
|
+
}
|
|
2628
|
+
Item.prototype.run = function () {
|
|
2629
|
+
this.fun.apply(null, this.array);
|
|
2630
|
+
};
|
|
2631
|
+
process.title = 'browser';
|
|
2632
|
+
process.browser = true;
|
|
2633
|
+
process.env = {};
|
|
2634
|
+
process.argv = [];
|
|
2635
|
+
process.version = ''; // empty string to avoid regexp issues
|
|
2636
|
+
process.versions = {};
|
|
2637
|
+
|
|
2638
|
+
function noop() {}
|
|
2639
|
+
|
|
2640
|
+
process.on = noop;
|
|
2641
|
+
process.addListener = noop;
|
|
2642
|
+
process.once = noop;
|
|
2643
|
+
process.off = noop;
|
|
2644
|
+
process.removeListener = noop;
|
|
2645
|
+
process.removeAllListeners = noop;
|
|
2646
|
+
process.emit = noop;
|
|
2647
|
+
|
|
2648
|
+
process.binding = function (name) {
|
|
2649
|
+
throw new Error('process.binding is not supported');
|
|
2650
|
+
};
|
|
2651
|
+
|
|
2652
|
+
process.cwd = function () { return '/' };
|
|
2653
|
+
process.chdir = function (dir) {
|
|
2654
|
+
throw new Error('process.chdir is not supported');
|
|
2655
|
+
};
|
|
2656
|
+
process.umask = function() { return 0; };
|
|
2657
|
+
|
|
2658
|
+
|
|
2659
|
+
/***/ },
|
|
2660
|
+
/* 14 */
|
|
2661
|
+
/***/ function(module, exports) {
|
|
2662
|
+
|
|
2663
|
+
module.exports = function isBuffer(arg) {
|
|
2664
|
+
return arg && typeof arg === 'object'
|
|
2665
|
+
&& typeof arg.copy === 'function'
|
|
2666
|
+
&& typeof arg.fill === 'function'
|
|
2667
|
+
&& typeof arg.readUInt8 === 'function';
|
|
2668
|
+
}
|
|
2669
|
+
|
|
2670
|
+
/***/ },
|
|
2671
|
+
/* 15 */
|
|
2672
|
+
/***/ function(module, exports) {
|
|
2673
|
+
|
|
2674
|
+
if (typeof Object.create === 'function') {
|
|
2675
|
+
// implementation from standard node.js 'util' module
|
|
2676
|
+
module.exports = function inherits(ctor, superCtor) {
|
|
2677
|
+
ctor.super_ = superCtor
|
|
2678
|
+
ctor.prototype = Object.create(superCtor.prototype, {
|
|
2679
|
+
constructor: {
|
|
2680
|
+
value: ctor,
|
|
2681
|
+
enumerable: false,
|
|
2682
|
+
writable: true,
|
|
2683
|
+
configurable: true
|
|
2684
|
+
}
|
|
2685
|
+
});
|
|
2686
|
+
};
|
|
2687
|
+
} else {
|
|
2688
|
+
// old school shim for old browsers
|
|
2689
|
+
module.exports = function inherits(ctor, superCtor) {
|
|
2690
|
+
ctor.super_ = superCtor
|
|
2691
|
+
var TempCtor = function () {}
|
|
2692
|
+
TempCtor.prototype = superCtor.prototype
|
|
2693
|
+
ctor.prototype = new TempCtor()
|
|
2694
|
+
ctor.prototype.constructor = ctor
|
|
2695
|
+
}
|
|
2696
|
+
}
|
|
2697
|
+
|
|
2698
|
+
|
|
2699
|
+
/***/ },
|
|
2700
|
+
/* 16 */
|
|
2701
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
2702
|
+
|
|
2703
|
+
'use strict';
|
|
2704
|
+
|
|
2705
|
+
Object.defineProperty(exports, "__esModule", {
|
|
2706
|
+
value: true
|
|
2707
|
+
});
|
|
2708
|
+
|
|
2709
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
2710
|
+
|
|
2711
|
+
var _class, _temp; // weak
|
|
2712
|
+
|
|
2713
|
+
var _looseLeaf = __webpack_require__(1);
|
|
2714
|
+
|
|
2715
|
+
var _looseLeaf2 = _interopRequireDefault(_looseLeaf);
|
|
2716
|
+
|
|
2717
|
+
var _attributeCable = __webpack_require__(2);
|
|
2718
|
+
|
|
2719
|
+
var _attributeCable2 = _interopRequireDefault(_attributeCable);
|
|
2720
|
+
|
|
2721
|
+
var _awaitingAck = __webpack_require__(17);
|
|
2722
|
+
|
|
2723
|
+
var _awaitingAck2 = _interopRequireDefault(_awaitingAck);
|
|
2724
|
+
|
|
2725
|
+
var _awaitingWithBuffer = __webpack_require__(19);
|
|
2726
|
+
|
|
2727
|
+
var _awaitingWithBuffer2 = _interopRequireDefault(_awaitingWithBuffer);
|
|
2728
|
+
|
|
2729
|
+
var _synchronized = __webpack_require__(20);
|
|
2730
|
+
|
|
2731
|
+
var _synchronized2 = _interopRequireDefault(_synchronized);
|
|
2732
|
+
|
|
2733
|
+
var _types = __webpack_require__(21);
|
|
2734
|
+
|
|
2735
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
2736
|
+
|
|
2737
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
2738
|
+
|
|
2739
|
+
var CollaborativeAttribute = (_temp = _class = function () {
|
|
2740
|
+
function CollaborativeAttribute(collaborate, attribute) {
|
|
2741
|
+
_classCallCheck(this, CollaborativeAttribute);
|
|
2742
|
+
|
|
2743
|
+
this.collaborate = collaborate;
|
|
2744
|
+
this.attribute = attribute;
|
|
2745
|
+
|
|
2746
|
+
if (!this.attribute) {
|
|
2747
|
+
throw new Error('You must specify an attribute to collaboratively edit');
|
|
2748
|
+
}
|
|
2749
|
+
|
|
2750
|
+
var event = new _looseLeaf2.default.Events();
|
|
2751
|
+
event.attachHandlers(this);
|
|
2752
|
+
this.documentId = this.collaborate.documentId;
|
|
2753
|
+
this.cable = new _attributeCable2.default(this, this.collaborate.cable, this.attribute);
|
|
2754
|
+
this.state = new _synchronized2.default(this);
|
|
2755
|
+
}
|
|
2756
|
+
|
|
2757
|
+
_createClass(CollaborativeAttribute, [{
|
|
2758
|
+
key: 'destroy',
|
|
2759
|
+
value: function destroy() {
|
|
2760
|
+
return this.cable.destroy();
|
|
2761
|
+
}
|
|
2762
|
+
}, {
|
|
2763
|
+
key: 'localOperation',
|
|
2764
|
+
value: function localOperation(operation) {
|
|
2765
|
+
if (operation.isNoop()) {
|
|
2766
|
+
return;
|
|
2767
|
+
}
|
|
2768
|
+
|
|
2769
|
+
return this.state.localOperation(operation);
|
|
2770
|
+
}
|
|
2771
|
+
}, {
|
|
2772
|
+
key: 'remoteOperation',
|
|
2773
|
+
value: function remoteOperation(data) {
|
|
2774
|
+
this.state.transformRemoteOperation(data);
|
|
2775
|
+
return this.trigger('remoteOperation', data.operation);
|
|
2776
|
+
}
|
|
2777
|
+
}, {
|
|
2778
|
+
key: 'receiveAck',
|
|
2779
|
+
value: function receiveAck(data) {
|
|
2780
|
+
return this.state.receiveAck(data);
|
|
2781
|
+
}
|
|
2782
|
+
}]);
|
|
2783
|
+
|
|
2784
|
+
return CollaborativeAttribute;
|
|
2785
|
+
}(), _class.AwaitingAck = _awaitingAck2.default, _class.AwaitingWithBuffer = _awaitingWithBuffer2.default, _class.Synchronized = _synchronized2.default, _temp);
|
|
2786
|
+
exports.default = CollaborativeAttribute;
|
|
2787
|
+
|
|
2788
|
+
/***/ },
|
|
2789
|
+
/* 17 */
|
|
2790
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
2791
|
+
|
|
2792
|
+
'use strict';
|
|
2793
|
+
|
|
2794
|
+
Object.defineProperty(exports, "__esModule", {
|
|
2795
|
+
value: true
|
|
2796
|
+
});
|
|
2797
|
+
exports.default = undefined;
|
|
2798
|
+
|
|
2799
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
2800
|
+
|
|
2801
|
+
var _ot = __webpack_require__(3);
|
|
2802
|
+
|
|
2803
|
+
var _ot2 = _interopRequireDefault(_ot);
|
|
2804
|
+
|
|
2805
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
2806
|
+
|
|
2807
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
2808
|
+
|
|
2809
|
+
var _state = __webpack_require__(18);
|
|
2810
|
+
|
|
2811
|
+
var _state2 = _interopRequireDefault(_state);
|
|
2812
|
+
|
|
2813
|
+
var _awaitingWithBuffer = __webpack_require__(19);
|
|
2814
|
+
|
|
2815
|
+
var _awaitingWithBuffer2 = _interopRequireDefault(_awaitingWithBuffer);
|
|
2816
|
+
|
|
2817
|
+
var _synchronized = __webpack_require__(20);
|
|
2818
|
+
|
|
2819
|
+
var _synchronized2 = _interopRequireDefault(_synchronized);
|
|
2820
|
+
|
|
2821
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
2822
|
+
|
|
2823
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
2824
|
+
|
|
2825
|
+
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
2826
|
+
|
|
2827
|
+
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // weak
|
|
2828
|
+
|
|
2829
|
+
|
|
2830
|
+
var AwaitingAck = function (_State) {
|
|
2831
|
+
_inherits(AwaitingAck, _State);
|
|
2832
|
+
|
|
2833
|
+
function AwaitingAck(collaborativeAttribute, operation) {
|
|
2834
|
+
_classCallCheck(this, AwaitingAck);
|
|
2835
|
+
|
|
2836
|
+
var _this = _possibleConstructorReturn(this, (AwaitingAck.__proto__ || Object.getPrototypeOf(AwaitingAck)).apply(this, arguments));
|
|
2837
|
+
|
|
2838
|
+
_this.operation = operation;
|
|
2839
|
+
return _this;
|
|
2840
|
+
}
|
|
2841
|
+
|
|
2842
|
+
_createClass(AwaitingAck, [{
|
|
2843
|
+
key: 'localOperation',
|
|
2844
|
+
value: function localOperation(operation) {
|
|
2845
|
+
this.collaborativeAttribute.state = new _awaitingWithBuffer2.default(this.collaborativeAttribute, this.operation, operation);
|
|
2846
|
+
}
|
|
2847
|
+
}, {
|
|
2848
|
+
key: 'receiveAck',
|
|
2849
|
+
value: function receiveAck(data) {
|
|
2850
|
+
this.collaborativeAttribute.state = new _synchronized2.default(this.collaborativeAttribute);
|
|
2851
|
+
}
|
|
2852
|
+
}, {
|
|
2853
|
+
key: 'transformRemoteOperation',
|
|
2854
|
+
value: function transformRemoteOperation(data) {
|
|
2855
|
+
var pair = _ot2.default.TextOperation.transform(this.operation, data.operation);
|
|
2856
|
+
this.operation = pair[0];
|
|
2857
|
+
data.operation = pair[1];
|
|
2858
|
+
}
|
|
2859
|
+
}]);
|
|
2860
|
+
|
|
2861
|
+
return AwaitingAck;
|
|
2862
|
+
}(_state2.default);
|
|
2863
|
+
|
|
2864
|
+
exports.default = AwaitingAck;
|
|
2865
|
+
;
|
|
2866
|
+
|
|
2867
|
+
/***/ },
|
|
2868
|
+
/* 18 */
|
|
2869
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
2870
|
+
|
|
2871
|
+
'use strict';
|
|
2872
|
+
|
|
2873
|
+
Object.defineProperty(exports, "__esModule", {
|
|
2874
|
+
value: true
|
|
2875
|
+
});
|
|
2876
|
+
exports.default = undefined;
|
|
2877
|
+
|
|
2878
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
2879
|
+
|
|
2880
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
2881
|
+
|
|
2882
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
2883
|
+
|
|
2884
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // weak
|
|
2885
|
+
|
|
2886
|
+
var State = function State(collaborativeAttribute) {
|
|
2887
|
+
_classCallCheck(this, State);
|
|
2888
|
+
|
|
2889
|
+
this.collaborativeAttribute = collaborativeAttribute;
|
|
2890
|
+
};
|
|
2891
|
+
|
|
2892
|
+
exports.default = State;
|
|
2893
|
+
|
|
2894
|
+
/***/ },
|
|
2895
|
+
/* 19 */
|
|
2896
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
2897
|
+
|
|
2898
|
+
'use strict';
|
|
2899
|
+
|
|
2900
|
+
Object.defineProperty(exports, "__esModule", {
|
|
2901
|
+
value: true
|
|
2902
|
+
});
|
|
2903
|
+
exports.default = undefined;
|
|
2904
|
+
|
|
2905
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
2906
|
+
|
|
2907
|
+
var _ot = __webpack_require__(3);
|
|
2908
|
+
|
|
2909
|
+
var _ot2 = _interopRequireDefault(_ot);
|
|
2910
|
+
|
|
2911
|
+
var _state = __webpack_require__(18);
|
|
2912
|
+
|
|
2913
|
+
var _state2 = _interopRequireDefault(_state);
|
|
2914
|
+
|
|
2915
|
+
var _awaitingAck = __webpack_require__(17);
|
|
2916
|
+
|
|
2917
|
+
var _awaitingAck2 = _interopRequireDefault(_awaitingAck);
|
|
2918
|
+
|
|
2919
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
2920
|
+
|
|
2921
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
2922
|
+
|
|
2923
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
2924
|
+
|
|
2925
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
2926
|
+
|
|
2927
|
+
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
2928
|
+
|
|
2929
|
+
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // weak
|
|
2930
|
+
|
|
2931
|
+
var AwaitingWithBuffer = function (_State) {
|
|
2932
|
+
_inherits(AwaitingWithBuffer, _State);
|
|
2933
|
+
|
|
2934
|
+
function AwaitingWithBuffer(collaborativeAttribute, operation, buffer) {
|
|
2935
|
+
_classCallCheck(this, AwaitingWithBuffer);
|
|
2936
|
+
|
|
2937
|
+
var _this = _possibleConstructorReturn(this, (AwaitingWithBuffer.__proto__ || Object.getPrototypeOf(AwaitingWithBuffer)).apply(this, arguments));
|
|
2938
|
+
|
|
2939
|
+
_this.operation = operation;
|
|
2940
|
+
_this.buffer = buffer;
|
|
2941
|
+
return _this;
|
|
2942
|
+
}
|
|
2943
|
+
|
|
2944
|
+
_createClass(AwaitingWithBuffer, [{
|
|
2945
|
+
key: 'localOperation',
|
|
2946
|
+
value: function localOperation(operation) {
|
|
2947
|
+
this.buffer = this.buffer.compose(operation);
|
|
2948
|
+
}
|
|
2949
|
+
}, {
|
|
2950
|
+
key: 'receiveAck',
|
|
2951
|
+
value: function receiveAck(data) {
|
|
2952
|
+
this.collaborativeAttribute.cable.sendOperation({
|
|
2953
|
+
operation: this.buffer
|
|
2954
|
+
});
|
|
2955
|
+
|
|
2956
|
+
this.collaborativeAttribute.state = new _awaitingAck2.default(this.collaborativeAttribute, this.buffer);
|
|
2957
|
+
}
|
|
2958
|
+
}, {
|
|
2959
|
+
key: 'transformRemoteOperation',
|
|
2960
|
+
value: function transformRemoteOperation(data) {
|
|
2961
|
+
var pair = _ot2.default.TextOperation.transform(this.operation, data.operation);
|
|
2962
|
+
this.operation = pair[0];
|
|
2963
|
+
data.operation = pair[1];
|
|
2964
|
+
pair = _ot2.default.TextOperation.transform(this.buffer, data.operation);
|
|
2965
|
+
this.buffer = pair[0];
|
|
2966
|
+
data.operation = pair[1];
|
|
2967
|
+
}
|
|
2968
|
+
}]);
|
|
2969
|
+
|
|
2970
|
+
return AwaitingWithBuffer;
|
|
2971
|
+
}(_state2.default);
|
|
2972
|
+
|
|
2973
|
+
exports.default = AwaitingWithBuffer;
|
|
2974
|
+
|
|
2975
|
+
/***/ },
|
|
2976
|
+
/* 20 */
|
|
2977
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
2978
|
+
|
|
2979
|
+
'use strict';
|
|
2980
|
+
|
|
2981
|
+
Object.defineProperty(exports, "__esModule", {
|
|
2982
|
+
value: true
|
|
2983
|
+
});
|
|
2984
|
+
exports.default = undefined;
|
|
2985
|
+
|
|
2986
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
2987
|
+
|
|
2988
|
+
var _state = __webpack_require__(18);
|
|
2989
|
+
|
|
2990
|
+
var _state2 = _interopRequireDefault(_state);
|
|
2991
|
+
|
|
2992
|
+
var _awaitingAck = __webpack_require__(17);
|
|
2993
|
+
|
|
2994
|
+
var _awaitingAck2 = _interopRequireDefault(_awaitingAck);
|
|
2995
|
+
|
|
2996
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
2997
|
+
|
|
2998
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
2999
|
+
|
|
3000
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
3001
|
+
|
|
3002
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
3003
|
+
|
|
3004
|
+
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
|
|
3005
|
+
|
|
3006
|
+
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // weak
|
|
3007
|
+
|
|
3008
|
+
var Synchronized = function (_State) {
|
|
3009
|
+
_inherits(Synchronized, _State);
|
|
3010
|
+
|
|
3011
|
+
function Synchronized() {
|
|
3012
|
+
_classCallCheck(this, Synchronized);
|
|
3013
|
+
|
|
3014
|
+
return _possibleConstructorReturn(this, (Synchronized.__proto__ || Object.getPrototypeOf(Synchronized)).apply(this, arguments));
|
|
3015
|
+
}
|
|
3016
|
+
|
|
3017
|
+
_createClass(Synchronized, [{
|
|
3018
|
+
key: 'localOperation',
|
|
3019
|
+
value: function localOperation(operation) {
|
|
3020
|
+
this.collaborativeAttribute.cable.sendOperation({
|
|
3021
|
+
operation: operation
|
|
3022
|
+
});
|
|
3023
|
+
|
|
3024
|
+
this.collaborativeAttribute.state = new _awaitingAck2.default(this.collaborativeAttribute, operation);
|
|
3025
|
+
}
|
|
3026
|
+
}, {
|
|
3027
|
+
key: 'receiveAck',
|
|
3028
|
+
value: function receiveAck(data) {
|
|
3029
|
+
console.error('Received an ack for version ' + data.version + ' whilst in Synchronized state.');
|
|
3030
|
+
}
|
|
3031
|
+
}, {
|
|
3032
|
+
key: 'transformRemoteOperation',
|
|
3033
|
+
value: function transformRemoteOperation(data) {}
|
|
3034
|
+
}]);
|
|
3035
|
+
|
|
3036
|
+
return Synchronized;
|
|
3037
|
+
}(_state2.default);
|
|
3038
|
+
|
|
3039
|
+
exports.default = Synchronized;
|
|
3040
|
+
|
|
3041
|
+
/***/ },
|
|
3042
|
+
/* 21 */
|
|
3043
|
+
/***/ function(module, exports) {
|
|
3044
|
+
|
|
3045
|
+
"use strict";
|
|
3046
|
+
|
|
3047
|
+
/***/ },
|
|
3048
|
+
/* 22 */
|
|
3049
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
3050
|
+
|
|
3051
|
+
'use strict';
|
|
3052
|
+
|
|
3053
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3054
|
+
value: true
|
|
3055
|
+
});
|
|
3056
|
+
exports.default = undefined;
|
|
3057
|
+
|
|
3058
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // weak
|
|
3059
|
+
|
|
3060
|
+
|
|
3061
|
+
var _looseLeaf = __webpack_require__(1);
|
|
3062
|
+
|
|
3063
|
+
var _looseLeaf2 = _interopRequireDefault(_looseLeaf);
|
|
3064
|
+
|
|
3065
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
3066
|
+
|
|
3067
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
3068
|
+
|
|
3069
|
+
var Cable = function () {
|
|
3070
|
+
function Cable(collaborate, cable, channel) {
|
|
3071
|
+
_classCallCheck(this, Cable);
|
|
3072
|
+
|
|
3073
|
+
this.collaborate = collaborate;
|
|
3074
|
+
this.unackedOps = [];
|
|
3075
|
+
this.attributeCables = {};
|
|
3076
|
+
this.documentId = this.collaborate.documentId;
|
|
3077
|
+
|
|
3078
|
+
this.subscription = cable.subscriptions.create({
|
|
3079
|
+
channel: channel,
|
|
3080
|
+
documentId: this.documentId
|
|
3081
|
+
}, {
|
|
3082
|
+
connected: this.connected.bind(this),
|
|
3083
|
+
received: this.received.bind(this)
|
|
3084
|
+
});
|
|
3085
|
+
}
|
|
3086
|
+
|
|
3087
|
+
_createClass(Cable, [{
|
|
3088
|
+
key: 'destroy',
|
|
3089
|
+
value: function destroy() {
|
|
3090
|
+
this.subscription.unsubscribe();
|
|
3091
|
+
}
|
|
3092
|
+
}, {
|
|
3093
|
+
key: 'addAttribute',
|
|
3094
|
+
value: function addAttribute(attribute, attributeCable) {
|
|
3095
|
+
this.attributeCables[attribute] = attributeCable;
|
|
3096
|
+
}
|
|
3097
|
+
}, {
|
|
3098
|
+
key: 'removeAttribute',
|
|
3099
|
+
value: function removeAttribute(attribute) {
|
|
3100
|
+
delete this.attributeCables[attribute];
|
|
3101
|
+
}
|
|
3102
|
+
}, {
|
|
3103
|
+
key: 'connected',
|
|
3104
|
+
value: function connected() {
|
|
3105
|
+
var _this = this;
|
|
3106
|
+
|
|
3107
|
+
return setTimeout(function () {
|
|
3108
|
+
_this.subscription.perform('document', {
|
|
3109
|
+
id: _this.documentId
|
|
3110
|
+
});
|
|
3111
|
+
|
|
3112
|
+
return console.info('Document Setup Complete');
|
|
3113
|
+
}, 200);
|
|
3114
|
+
}
|
|
3115
|
+
}, {
|
|
3116
|
+
key: 'received',
|
|
3117
|
+
value: function received(data) {
|
|
3118
|
+
switch (data.action) {
|
|
3119
|
+
case 'subscribed':
|
|
3120
|
+
return this.subscribed(data);
|
|
3121
|
+
case 'attribute':
|
|
3122
|
+
return this.receiveAttribute(data);
|
|
3123
|
+
case 'operation':
|
|
3124
|
+
return this.receiveOperation(data);
|
|
3125
|
+
default:
|
|
3126
|
+
console.warn(data.action + ' unhandled');
|
|
3127
|
+
return console.info(data);
|
|
3128
|
+
}
|
|
3129
|
+
}
|
|
3130
|
+
}, {
|
|
3131
|
+
key: 'sendOperation',
|
|
3132
|
+
value: function sendOperation(data) {
|
|
3133
|
+
data.client_id = this.clientId;
|
|
3134
|
+
data.document_id = this.documentId;
|
|
3135
|
+
return this.subscription.perform('operation', data);
|
|
3136
|
+
}
|
|
3137
|
+
}, {
|
|
3138
|
+
key: 'subscribed',
|
|
3139
|
+
value: function subscribed(data) {
|
|
3140
|
+
this.clientId = data.client_id;
|
|
3141
|
+
console.log('Set client ID as ' + this.clientId);
|
|
3142
|
+
}
|
|
3143
|
+
}, {
|
|
3144
|
+
key: 'receiveAttribute',
|
|
3145
|
+
value: function receiveAttribute(data) {
|
|
3146
|
+
if (data.document_id !== this.documentId) {
|
|
3147
|
+
return;
|
|
3148
|
+
}
|
|
3149
|
+
|
|
3150
|
+
var attributeCable = this.attributeCables[data.attribute];
|
|
3151
|
+
|
|
3152
|
+
if (!attributeCable) {
|
|
3153
|
+
console.warn('Received collaboration message for ' + data.attribute + ', but it has not been registered');
|
|
3154
|
+
|
|
3155
|
+
return;
|
|
3156
|
+
}
|
|
3157
|
+
|
|
3158
|
+
return attributeCable.receiveAttribute(data);
|
|
3159
|
+
}
|
|
3160
|
+
}, {
|
|
3161
|
+
key: 'receiveOperation',
|
|
3162
|
+
value: function receiveOperation(data) {
|
|
3163
|
+
if (data.document_id !== this.documentId) {
|
|
3164
|
+
return;
|
|
3165
|
+
}
|
|
3166
|
+
|
|
3167
|
+
var attributeCable = this.attributeCables[data.attribute];
|
|
3168
|
+
|
|
3169
|
+
if (!attributeCable) {
|
|
3170
|
+
console.warn('Received collaboration message for ' + data.attribute + ', but it has not been registered');
|
|
3171
|
+
|
|
3172
|
+
return;
|
|
3173
|
+
}
|
|
3174
|
+
|
|
3175
|
+
return attributeCable.receiveOperation(data);
|
|
3176
|
+
}
|
|
3177
|
+
}]);
|
|
3178
|
+
|
|
3179
|
+
return Cable;
|
|
3180
|
+
}();
|
|
3181
|
+
|
|
3182
|
+
exports.default = Cable;
|
|
3183
|
+
;
|
|
3184
|
+
|
|
3185
|
+
/***/ },
|
|
3186
|
+
/* 23 */
|
|
3187
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
3188
|
+
|
|
3189
|
+
'use strict';
|
|
3190
|
+
|
|
3191
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3192
|
+
value: true
|
|
3193
|
+
});
|
|
3194
|
+
|
|
3195
|
+
var _textareaAdapter = __webpack_require__(24);
|
|
3196
|
+
|
|
3197
|
+
var _textareaAdapter2 = _interopRequireDefault(_textareaAdapter);
|
|
3198
|
+
|
|
3199
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
3200
|
+
|
|
3201
|
+
exports.default = {
|
|
3202
|
+
TextAreaAdapter: _textareaAdapter2.default
|
|
3203
|
+
};
|
|
3204
|
+
|
|
3205
|
+
/***/ },
|
|
3206
|
+
/* 24 */
|
|
3207
|
+
/***/ function(module, exports, __webpack_require__) {
|
|
3208
|
+
|
|
3209
|
+
'use strict';
|
|
3210
|
+
|
|
3211
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3212
|
+
value: true
|
|
3213
|
+
});
|
|
3214
|
+
exports.default = undefined;
|
|
3215
|
+
|
|
3216
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // weak
|
|
3217
|
+
|
|
3218
|
+
var _ot = __webpack_require__(3);
|
|
3219
|
+
|
|
3220
|
+
var _ot2 = _interopRequireDefault(_ot);
|
|
3221
|
+
|
|
3222
|
+
var _collaborativeAttribute = __webpack_require__(16);
|
|
3223
|
+
|
|
3224
|
+
var _collaborativeAttribute2 = _interopRequireDefault(_collaborativeAttribute);
|
|
3225
|
+
|
|
3226
|
+
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
3227
|
+
|
|
3228
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
3229
|
+
|
|
3230
|
+
var TextAreaAdapter = function () {
|
|
3231
|
+
function TextAreaAdapter(collaborativeAttribute, textarea) {
|
|
3232
|
+
_classCallCheck(this, TextAreaAdapter);
|
|
3233
|
+
|
|
3234
|
+
this.collaborativeAttribute = collaborativeAttribute;
|
|
3235
|
+
this.$textarea = textarea;
|
|
3236
|
+
this.oldContent = this.$textarea.value;
|
|
3237
|
+
|
|
3238
|
+
var _arr = ['keyup', 'cut', 'paste'];
|
|
3239
|
+
for (var _i = 0; _i < _arr.length; _i++) {
|
|
3240
|
+
var eventName = _arr[_i];
|
|
3241
|
+
this.$textarea.addEventListener(eventName, this.textChange.bind(this));
|
|
3242
|
+
}
|
|
3243
|
+
|
|
3244
|
+
this.collaborativeAttribute.on('remoteOperation', this.applyRemoteOperation.bind(this));
|
|
3245
|
+
}
|
|
3246
|
+
|
|
3247
|
+
_createClass(TextAreaAdapter, [{
|
|
3248
|
+
key: 'textChange',
|
|
3249
|
+
value: function textChange() {
|
|
3250
|
+
var newContent = this.$textarea.value;
|
|
3251
|
+
var operation = this.operationFromTextChange(this.oldContent, newContent);
|
|
3252
|
+
this.oldContent = newContent;
|
|
3253
|
+
return this.collaborativeAttribute.localOperation(operation);
|
|
3254
|
+
}
|
|
3255
|
+
}, {
|
|
3256
|
+
key: 'operationFromTextChange',
|
|
3257
|
+
value: function operationFromTextChange(oldContent, newContent) {
|
|
3258
|
+
var op = new _ot2.default.TextOperation();
|
|
3259
|
+
|
|
3260
|
+
if (oldContent === newContent) {
|
|
3261
|
+
return op;
|
|
3262
|
+
}
|
|
3263
|
+
|
|
3264
|
+
var commonStart = 0;
|
|
3265
|
+
|
|
3266
|
+
while (oldContent.charAt(commonStart) === newContent.charAt(commonStart)) {
|
|
3267
|
+
commonStart++;
|
|
3268
|
+
}
|
|
3269
|
+
|
|
3270
|
+
var commonEnd = 0;
|
|
3271
|
+
|
|
3272
|
+
while (oldContent.charAt(oldContent.length - 1 - commonEnd) === newContent.charAt(newContent.length - 1 - commonEnd)) {
|
|
3273
|
+
if (commonEnd + commonStart === oldContent.length) {
|
|
3274
|
+
break;
|
|
3275
|
+
}
|
|
3276
|
+
|
|
3277
|
+
if (commonEnd + commonStart === newContent.length) {
|
|
3278
|
+
break;
|
|
3279
|
+
}
|
|
3280
|
+
|
|
3281
|
+
commonEnd++;
|
|
3282
|
+
}
|
|
3283
|
+
|
|
3284
|
+
op.retain(commonStart);
|
|
3285
|
+
|
|
3286
|
+
if (oldContent.length !== commonStart + commonEnd) {
|
|
3287
|
+
op.delete(oldContent.length - commonStart - commonEnd);
|
|
3288
|
+
}
|
|
3289
|
+
|
|
3290
|
+
if (newContent.length !== commonStart + commonEnd) {
|
|
3291
|
+
op.insert(newContent.slice(commonStart, newContent.length - commonEnd));
|
|
3292
|
+
}
|
|
3293
|
+
|
|
3294
|
+
op.retain(commonEnd);
|
|
3295
|
+
return op;
|
|
3296
|
+
}
|
|
3297
|
+
}, {
|
|
3298
|
+
key: 'applyRemoteOperation',
|
|
3299
|
+
value: function applyRemoteOperation(operation) {
|
|
3300
|
+
var content = operation.apply(this.oldContent);
|
|
3301
|
+
var selectionStart = this.$textarea.selectionStart;
|
|
3302
|
+
var selectionEnd = this.$textarea.selectionEnd;
|
|
3303
|
+
this.$textarea.value = content;
|
|
3304
|
+
this.$textarea.setSelectionRange(selectionStart, selectionEnd);
|
|
3305
|
+
this.oldContent = content;
|
|
3306
|
+
}
|
|
3307
|
+
}]);
|
|
3308
|
+
|
|
3309
|
+
return TextAreaAdapter;
|
|
3310
|
+
}();
|
|
3311
|
+
|
|
3312
|
+
exports.default = TextAreaAdapter;
|
|
3313
|
+
|
|
3314
|
+
/***/ },
|
|
3315
|
+
/* 25 */
|
|
3316
|
+
/***/ function(module, exports) {
|
|
3317
|
+
|
|
3318
|
+
"use strict";
|
|
3319
|
+
|
|
3320
|
+
Object.defineProperty(exports, "__esModule", {
|
|
3321
|
+
value: true
|
|
3322
|
+
});
|
|
3323
|
+
|
|
3324
|
+
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
3325
|
+
|
|
3326
|
+
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
3327
|
+
|
|
3328
|
+
// weak
|
|
3329
|
+
|
|
3330
|
+
var Events = function () {
|
|
3331
|
+
function Events(object) {
|
|
3332
|
+
_classCallCheck(this, Events);
|
|
3333
|
+
|
|
3334
|
+
this._listeners = [];
|
|
3335
|
+
}
|
|
3336
|
+
|
|
3337
|
+
_createClass(Events, [{
|
|
3338
|
+
key: "attachHandlers",
|
|
3339
|
+
value: function attachHandlers(object) {
|
|
3340
|
+
object.on = this.on.bind(this);
|
|
3341
|
+
object.off = this.off.bind(this);
|
|
3342
|
+
object.trigger = this.trigger.bind(this);
|
|
3343
|
+
}
|
|
3344
|
+
}, {
|
|
3345
|
+
key: "on",
|
|
3346
|
+
value: function on(eventName, callback) {
|
|
3347
|
+
this._listeners[eventName] || (this._listeners[eventName] = []);
|
|
3348
|
+
return this._listeners[eventName].push(callback);
|
|
3349
|
+
}
|
|
3350
|
+
}, {
|
|
3351
|
+
key: "off",
|
|
3352
|
+
value: function off(eventName, callback) {
|
|
3353
|
+
if (!callback) {
|
|
3354
|
+
delete this._listeners[eventName];
|
|
3355
|
+
return;
|
|
3356
|
+
}
|
|
3357
|
+
|
|
3358
|
+
var index = this._listeners[eventName].indexOf(callback);
|
|
3359
|
+
return this._listeners.splice(index, 1);
|
|
3360
|
+
}
|
|
3361
|
+
}, {
|
|
3362
|
+
key: "trigger",
|
|
3363
|
+
value: function trigger(eventName) {
|
|
3364
|
+
for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
3365
|
+
args[_key - 1] = arguments[_key];
|
|
3366
|
+
}
|
|
3367
|
+
|
|
3368
|
+
var listeners = this._listeners[eventName] || [];
|
|
3369
|
+
|
|
3370
|
+
return function () {
|
|
3371
|
+
var _iteratorNormalCompletion = true;
|
|
3372
|
+
var _didIteratorError = false;
|
|
3373
|
+
var _iteratorError = undefined;
|
|
3374
|
+
|
|
3375
|
+
try {
|
|
3376
|
+
for (var _iterator = listeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
|
|
3377
|
+
var callback = _step.value;
|
|
3378
|
+
|
|
3379
|
+
callback.apply(undefined, args);
|
|
3380
|
+
}
|
|
3381
|
+
} catch (err) {
|
|
3382
|
+
_didIteratorError = true;
|
|
3383
|
+
_iteratorError = err;
|
|
3384
|
+
} finally {
|
|
3385
|
+
try {
|
|
3386
|
+
if (!_iteratorNormalCompletion && _iterator.return) {
|
|
3387
|
+
_iterator.return();
|
|
3388
|
+
}
|
|
3389
|
+
} finally {
|
|
3390
|
+
if (_didIteratorError) {
|
|
3391
|
+
throw _iteratorError;
|
|
3392
|
+
}
|
|
3393
|
+
}
|
|
3394
|
+
}
|
|
3395
|
+
}();
|
|
3396
|
+
}
|
|
3397
|
+
}]);
|
|
3398
|
+
|
|
3399
|
+
return Events;
|
|
3400
|
+
}();
|
|
3401
|
+
|
|
3402
|
+
exports.default = Events;
|
|
3403
|
+
;
|
|
3404
|
+
|
|
3405
|
+
/***/ }
|
|
3406
|
+
/******/ ])
|
|
3407
|
+
});
|
|
3408
|
+
;
|