├── .gitignore
├── LICENSE
├── README.md
├── gulpfile.js
├── package.json
├── plugin.xml
├── scripts-src
    └── fetch-js-client.js
├── scripts
    └── fetch-js-client.js
└── src
    ├── android
        └── OpenTokPlugin.java
    ├── browser
        └── .gitkeep
    └── ios
        └── OpenTokPlugin.m


/.gitignore:
--------------------------------------------------------------------------------
1 | # node.js
2 | npm-debug.log
3 | /node_modules
4 | .idea/
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Ankur Oberoi
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # OpenTokJS Cordova Plugin
  2 | 
  3 | A [Cordova](https://cordova.apache.org/) plugin to enable use of
  4 | [OpenTok](https://tokbox.com/platform) on the iOS, Android, and Browser platforms.
  5 | 
  6 | *WARNING:* This plugin is prerelease quality for versions less than `1.0.0`.
  7 | 
  8 | ## Install
  9 | 
 10 | Using the Cordova CLI:
 11 | 
 12 | `$ cordova plugin add cordova-plugin-opentokjs --save --shrinkwrap`
 13 | 
 14 | ## Configuration
 15 | 
 16 | The version of the opentok.js SDK included into your project can be specified by a platform
 17 | preference in your `config.xml`:
 18 | 
 19 | ```
 20 | <preference name="OpentokClientVersion" value="v2"/>
 21 | ```
 22 | 
 23 | The default version string is "v2". It behaves similar to semantic versioning. You can accept more
 24 | updates automatically by being less specific: "v2" matches versions greater than or equal to
 25 | "v2.0.0" and less than "v3.0.0". You can restrict updates by being more specific: "v2.6.0" matches
 26 | just that version.
 27 | 
 28 | ## Example applications
 29 | 
 30 | Basic Example app: <https://github.com/aoberoi/hello-opentokjs-cordova>.
 31 | 
 32 | Ionic example: <https://github.com/Mobilea/cordova-plugin-opentokjs-example>.
 33 | 
 34 | ## About this Plugin
 35 | 
 36 | *How is this different from the com.tokbox.cordova.opentok plugin?*
 37 | 
 38 | The goal of this plugin is be as maintainable and portable as possible. During development of the
 39 | [com.tokbox.cordova.opentok](http://plugins.cordova.io/#/package/com.tokbox.cordova.opentok) plugin,
 40 | it became apparent that the amount of effort it would take to maintain a JavaScript wrapper layer
 41 | which mimicked the official opentok.js SDK, even as the SDK kept receiving changes and updates, was
 42 | not sustainable for the community. In response to this observation, this plugin takes a drastically
 43 | different approach to architecture.
 44 | 
 45 | The approach is to run the official opentok.js client SDK, with as few changes as possible, on top
 46 | of lower level plugins that present the standard WebRTC based APIs. This is possible thanks to
 47 | projects such as [Crosswalk](https://crosswalk-project.org/) by Intel Corporation and the
 48 | [cordova-plugin-iosrtc](http://plugins.cordova.io/#/package/cordova-plugin-iosrtc) plugin from
 49 | eFace2Face, Inc.
 50 | 
 51 | Any source transformations to the official opentok.js client SDK that are applied within this plugin
 52 | should hopefully go away as the lower level implementations come closer to standards and the SDK
 53 | becomes more generalized to support these types of use cases.
 54 | 
 55 | ### Known Limitations
 56 | 
 57 | iOS:
 58 | 
 59 | *  The library must be loaded manually after ensuring the iosrtc globals are inserted first. See
 60 |    sample below:
 61 | 
 62 |    ```javascript
 63 |    function onDeviceReady() {
 64 |      if (window.device.platform === 'iOS') {
 65 |        cordova.plugins.iosrtc.registerGlobals();
 66 |        window.OT = cordova.require('cordova-plugin-opentokjs.OpenTokClient');
 67 |      }
 68 |      // You can now use OT
 69 |    }
 70 |    ```
 71 | 
 72 | *  Denying access to the camera or microphone after it is requested (iOS's permission prompt) will
 73 |    cause a crash.
 74 | 
 75 | *  A publisher's view is not size properly. It behaves similar to `fitMode: 'contain'`, where the
 76 |    image is letter/pillar boxed into the size of the publisher element. This might also affect
 77 |    subscriber streams from other devices, but remains to be tested.
 78 | 
 79 | *  You cannot draw any UI over the video streams. This is a limitation imposed by the fact that the
 80 |    rendering is always done in a UIView over top of the Cordova web view.
 81 | 
 82 | *  Building the project in Xcode requires special care. See the
 83 |    [instructions inside the iosrtc project](https://github.com/eface2face/cordova-plugin-iosrtc/blob/master/docs/Building.md).
 84 | 
 85 | ### New API
 86 | 
 87 | iOS:
 88 | 
 89 | *  When resizing or moving any publisher/subscriber elements (with contained `<video>` elements),
 90 |    you will need to call the `cordova.plugins.iosrtc.refreshVideos()` method after the DOM operation
 91 |    to reposition the UIViews that are over top of the web view.
 92 | 
 93 | ## Support
 94 | 
 95 | Please file a GitHub Issue for any questions you might have. Someone from the community will try
 96 | to assist you when possible. This project is a community-based effort and not supported by
 97 | TokBox, Inc. Please be patient and constructive.
 98 | 
 99 | ## Contributing
100 | 
101 | There are a few ways you can help contribute to this project:
102 | 
103 | *  If you find a bug, please file it in the GitHub Issues page. Be descriptive and include steps to
104 |    reproduce the problem (sample code if possible).
105 | 
106 | *  If you have feature requests, file it in the Github Issues page. If you already see the feature
107 |    you desire listed, feel free to comment within the conversation.
108 | 
109 | *  If you can offer a change or a fix, we :heart: pull requests! If its a large change, please try
110 |    to start a discussion on the GitHub Issues before spending too much time on the work, so that you
111 |    can get an idea of if the maintainers would be able to merge the changes. If its something small,
112 |    such as documentation, tests, etc., go ahead and send the changes as a PR. See the development
113 |    guidelines below.
114 | 
115 | ### Development
116 | 
117 | You must have node, npm, and gulp installed to develop for this package. Run `npm install` before
118 | beginning work.
119 | 
120 | Any changes scripts should happen in the `scripts-src` directory. Before committing changes, run the
121 | `gulp scripts` command to build the version for the `scripts` directory.
122 | 


--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
 1 | var gulp = require('gulp');
 2 | var browserify = require('browserify');
 3 | var source = require('vinyl-source-stream');
 4 | 
 5 | gulp.task('scripts', function() {
 6 |   var b = browserify({
 7 |     entries: './scripts-src/fetch-js-client.js',
 8 | 
 9 |     // no-builtins, no-commondir, insert-global-vars="__filename,__dirname", no-browser-field
10 |     builtins: [],
11 |     commondir: false,
12 |     insertGlobalVars: ['__filename', '__dirname'],
13 |     detectGlobals: false,
14 |     browserField: false,
15 |     standalone: 'module.exports'
16 |   });
17 | 
18 |   return b.bundle()
19 |     .pipe(source('fetch-js-client.js'))
20 |     .pipe(gulp.dest('./scripts/'));
21 | });
22 | 
23 | gulp.task('default', ['scripts']);
24 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cordova-plugin-opentokjs",
 3 |   "version": "0.1.2",
 4 |   "cordova": {
 5 |     "id": "cordova-plugin-opentokjs",
 6 |     "platforms": [
 7 |       "ios",
 8 |       "android",
 9 |       "browser"
10 |     ]
11 |   },
12 |   "description": "OpenTok lets you weave real time communications with live video and audio into your application",
13 |   "engines": [
14 |     {
15 |       "name": "cordova-android",
16 |       "version": ">=4.0.0"
17 |     },
18 |     {
19 |       "name": "cordova-ios",
20 |       "version": ">=3.8.0"
21 |     }
22 |   ],
23 |   "keywords": [
24 |     "cordova",
25 |     "ecosystem:cordova",
26 |     "opentok",
27 |     "tokbox",
28 |     "video-chat",
29 |     "webrtc",
30 |     "realtime",
31 |     "cordova-ios",
32 |     "cordova-android",
33 |     "rtc"
34 |   ],
35 |   "homepage": "https://github.com/aoberoi/cordova-plugin-opentokjs",
36 |   "repository": {
37 |     "type": "git",
38 |     "url": "https://github.com/aoberoi/cordova-plugin-opentokjs.git"
39 |   },
40 |   "bugs": {
41 |     "url": "https://github.com/aoberoi/cordova-plugin-opentokjs/issues"
42 |   },
43 |   "peerDependencies": {
44 |     "cordova-plugin-crosswalk-webview": "^1.2.0"
45 |   },
46 |   "devDependencies": {
47 |     "browserify": "^10.2.4",
48 |     "event-stream": "^3.3.1",
49 |     "gulp": "^3.9.0",
50 |     "replacestream": "^2.1.0",
51 |     "vinyl-source-stream": "^1.1.0"
52 |   },
53 |   "author": "Ankur Oberoi <aoberoi@gmail.com>",
54 |   "license": "MIT"
55 | }
56 | 


--------------------------------------------------------------------------------
/plugin.xml:
--------------------------------------------------------------------------------
 1 | <?xml version='1.0' encoding='utf-8'?>
 2 | <plugin id="cordova-plugin-opentokjs" version="0.1.2" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android">
 3 |   <name>OpenTokPlugin</name>
 4 |   <description />
 5 |   <author>Ankur Oberoi</author>
 6 |   <license>MIT</license>
 7 |   <keywords>opentok,tokbox,video-chat,webrtc,realtime,rtc</keywords>
 8 | 
 9 |   <info>
10 |     OpenTok lets you weave real time communications with live video, audio, and data messaging into your application.
11 |     Learn more: &gt;https://tokbox.com/platform&lt;
12 |   </info>
13 | 
14 |   <engines>
15 |     <!-- TODO: what are the platform and the cordova engine requirements? -->
16 |   </engines>
17 | 
18 |   <!-- only needed for android -->
19 |   <dependency id="cordova-plugin-crosswalk-webview" spec="^1.2.0" />
20 | 
21 |   <!-- only needed for ios -->
22 |   <dependency id="cordova-plugin-iosrtc" spec="^1.3.0" />
23 | 
24 |   <!-- TODO: do we need any native code for android? -->
25 |   <platform name="android">
26 |     <hook type="before_plugin_install" src="scripts/fetch-js-client.js" />
27 | 
28 |     <config-file parent="/*" target="res/xml/config.xml">
29 |       <feature name="OpenTokPlugin">
30 |         <param name="android-package" value="me.aoberoi.cordova.opentokjs.OpenTokPlugin" />
31 |       </feature>
32 |     </config-file>
33 | 
34 |     <config-file parent="/*" target="AndroidManifest.xml">
35 |       <uses-permission android:name="android.permission.RECORD_AUDIO" />
36 |       <uses-permission android:name="android.permission.CAMERA" />
37 |     </config-file>
38 | 
39 |     <source-file src="src/android/OpenTokPlugin.java" target-dir="src/me/aoberoi/cordova/opentokjs/OpenTokPlugin" />
40 | 
41 |     <js-module src="src/android/opentok.js" name="OpenTokClient">
42 |       <clobbers target="OT"/>
43 |     </js-module>
44 |   </platform>
45 | 
46 |   <!-- TODO: do we need any native code for ios? -->
47 |   <platform name="ios">
48 |     <hook type="before_plugin_install" src="scripts/fetch-js-client.js" />
49 | 
50 |     <config-file parent="/*" target="config.xml">
51 |       <feature name="OpenTokPlugin">
52 |         <param name="ios-package" value="OpenTokPlugin" />
53 |       </feature>
54 |     </config-file>
55 | 
56 |     <source-file src="src/ios/OpenTokPlugin.m" />
57 | 
58 |     <js-module src="src/ios/opentok.js" name="OpenTokClient">
59 |     </js-module>
60 |   </platform>
61 | 
62 |   <platform name="browser">
63 |     <hook type="before_plugin_install" src="scripts/fetch-js-client.js" />
64 |     <js-module src="src/browser/opentok.js" name="OpenTokClient">
65 |       <clobbers target="OT"/>
66 |     </js-module>
67 |   </platform>
68 | </plugin>
69 | 


--------------------------------------------------------------------------------
/scripts-src/fetch-js-client.js:
--------------------------------------------------------------------------------
 1 | var path = require('path');
 2 | var fs = require('fs');
 3 | var https = require('https');
 4 | var replacestream = require('replacestream');
 5 | var through = require('event-stream').through;
 6 | 
 7 | var clientUrl = 'https://static.opentok.com/VERSION/js/opentok.js';
 8 | 
 9 | // Fetch OpenTok.js client
10 | // This script will run once per platform where the hook is applied
11 | // Acknowledgement: This script was inspired by original work from Callan Iwan Kandasamy
12 | // (https://github.com/CallanIwan), contained in
13 | // https://github.com/songz/cordova-plugin-opentok/pull/176
14 | 
15 | // TODO: make a separate script that can be run to update the library after the plugin is installed
16 | module.exports = function(context) {
17 | 
18 |   var Q = context.requireCordovaModule('q');
19 |   var osenv = context.requireCordovaModule('osenv');
20 |   var ConfigParser = context.requireCordovaModule('../configparser/ConfigParser');
21 | 
22 |   var deferral = Q.defer();
23 | 
24 |   var config = new ConfigParser(path.join(context.opts.projectRoot, 'config.xml'));
25 |   var opentokClientVersion =
26 |     config.getPreference('OpentokClientVersion', context.opts.plugin.platform) || 'v2';
27 | 
28 |   var modulePath =
29 |     path.join(context.opts.plugin.dir, 'src', context.opts.plugin.platform, 'opentok.js');
30 | 
31 |   // TODO: error handling
32 |   var moduleWriteStream = fs.createWriteStream(modulePath);
33 |   moduleWriteStream.on('open', function() {
34 |     https.get(clientUrl.replace('VERSION', opentokClientVersion), function(res) {
35 |       var sourceStream = res.pipe(replacestream(/if \(location\.protocol === 'file:'\) {[^}]*}/gm, '/* removed by cordova-plugin-opentokjs */', {
36 |         max_match_len: 1000
37 |       }));
38 | 
39 |       if (context.opts.plugin.platform === 'ios') {
40 |         sourceStream = sourceStream.pipe(replacestream('var isSupported = $.env.name === \'Safari\' ||\n                  ($.env.name === \'IE\' && $.env.version >= 8 &&', 'var isSupported =  ($.env.name === \'IE\' && $.env.version >= 8 &&', {
41 |           max_match_len: 1000
42 |         }))
43 |         .pipe(replacestream('loadedEvent = webRtcStream.getVideoTracks().length > minVideoTracksForTimeUpdate ?\n          \'timeupdate\' : \'loadedmetadata\';', 'loadedEvent = \'loadedmetadata\';', {
44 |           max_match_len: 1000
45 |         }))
46 |         .pipe(replacestream('onError = function onError (event) {\n          cleanup();\n          unbindNativeStream(videoElement);\n', 'onError = function onError (event) {\n          if (event.target.error.code === window.MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED) {\n            return onLoad();\n          }\n          cleanup();\n          unbindNativeStream(videoElement);\n', {
47 |           max_match_len: 1000
48 |         }))
49 |         .pipe(replacestream('var _onVideoError = OT.$.bind(function(event) {\n', 'var _onVideoError = OT.$.bind(function(event) {\n          if (event.target.error.code === window.MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED) {\n            return;\n          }\n', {
50 |           max_match_len: 1000
51 |         }));
52 |       }
53 | 
54 |       sourceStream.pipe(through(
55 |         function write(data) {
56 |           this.emit('data', data);
57 |         },
58 | 
59 |         function end() {
60 |           this.emit('data', '\n// cordova-plugin-opentok injected export\nmodule.exports = window.OT;\n');
61 |           this.emit('end');
62 |         }))
63 |       .pipe(moduleWriteStream)
64 |       .on('finish', function() {
65 |         deferral.resolve();
66 |       });
67 |     });
68 |   });
69 | 
70 |   return deferral.promise;
71 | };
72 | 


--------------------------------------------------------------------------------
/scripts/fetch-js-client.js:
--------------------------------------------------------------------------------
   1 | (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}(g.module || (g.module = {})).exports = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2 | //filter will reemit the data if cb(err,pass) pass is truthy
   3 | 
   4 | // reduce is more tricky
   5 | // maybe we want to group the reductions or emit progress updates occasionally
   6 | // the most basic reduce just emits one 'data' event after it has recieved 'end'
   7 | 
   8 | var Stream = require('stream').Stream
   9 |   , es = exports
  10 |   , through = require('through')
  11 |   , from = require('from')
  12 |   , duplex = require('duplexer')
  13 |   , map = require('map-stream')
  14 |   , pause = require('pause-stream')
  15 |   , split = require('split')
  16 |   , pipeline = require('stream-combiner')
  17 |   , immediately = global.setImmediate || process.nextTick;
  18 | 
  19 | es.Stream = Stream //re-export Stream from core
  20 | es.through = through
  21 | es.from = from
  22 | es.duplex = duplex
  23 | es.map = map
  24 | es.pause = pause
  25 | es.split = split
  26 | es.pipeline = es.connect = es.pipe = pipeline
  27 | // merge / concat
  28 | //
  29 | // combine multiple streams into a single stream.
  30 | // will emit end only once
  31 | 
  32 | es.concat = //actually this should be called concat
  33 | es.merge = function (/*streams...*/) {
  34 |   var toMerge = [].slice.call(arguments)
  35 |   if (toMerge.length === 1 && (toMerge[0] instanceof Array)) {
  36 |     toMerge = toMerge[0] //handle array as arguments object
  37 |   }
  38 |   var stream = new Stream()
  39 |   stream.setMaxListeners(0) // allow adding more than 11 streams
  40 |   var endCount = 0
  41 |   stream.writable = stream.readable = true
  42 | 
  43 |   toMerge.forEach(function (e) {
  44 |     e.pipe(stream, {end: false})
  45 |     var ended = false
  46 |     e.on('end', function () {
  47 |       if(ended) return
  48 |       ended = true
  49 |       endCount ++
  50 |       if(endCount == toMerge.length)
  51 |         stream.emit('end') 
  52 |     })
  53 |   })
  54 |   stream.write = function (data) {
  55 |     this.emit('data', data)
  56 |   }
  57 |   stream.destroy = function () {
  58 |     toMerge.forEach(function (e) {
  59 |       if(e.destroy) e.destroy()
  60 |     })
  61 |   }
  62 |   return stream
  63 | }
  64 | 
  65 | 
  66 | // writable stream, collects all events into an array 
  67 | // and calls back when 'end' occurs
  68 | // mainly I'm using this to test the other functions
  69 | 
  70 | es.writeArray = function (done) {
  71 |   if ('function' !== typeof done)
  72 |     throw new Error('function writeArray (done): done must be function')
  73 | 
  74 |   var a = new Stream ()
  75 |     , array = [], isDone = false
  76 |   a.write = function (l) {
  77 |     array.push(l)
  78 |   }
  79 |   a.end = function () {
  80 |     isDone = true
  81 |     done(null, array)
  82 |   }
  83 |   a.writable = true
  84 |   a.readable = false
  85 |   a.destroy = function () {
  86 |     a.writable = a.readable = false
  87 |     if(isDone) return
  88 |     done(new Error('destroyed before end'), array)
  89 |   }
  90 |   return a
  91 | }
  92 | 
  93 | //return a Stream that reads the properties of an object
  94 | //respecting pause() and resume()
  95 | 
  96 | es.readArray = function (array) {
  97 |   var stream = new Stream()
  98 |     , i = 0
  99 |     , paused = false
 100 |     , ended = false
 101 |  
 102 |   stream.readable = true  
 103 |   stream.writable = false
 104 |  
 105 |   if(!Array.isArray(array))
 106 |     throw new Error('event-stream.read expects an array')
 107 |   
 108 |   stream.resume = function () {
 109 |     if(ended) return
 110 |     paused = false
 111 |     var l = array.length
 112 |     while(i < l && !paused && !ended) {
 113 |       stream.emit('data', array[i++])
 114 |     }
 115 |     if(i == l && !ended)
 116 |       ended = true, stream.readable = false, stream.emit('end')
 117 |   }
 118 |   process.nextTick(stream.resume)
 119 |   stream.pause = function () {
 120 |      paused = true
 121 |   }
 122 |   stream.destroy = function () {
 123 |     ended = true
 124 |     stream.emit('close')
 125 |   }
 126 |   return stream
 127 | }
 128 | 
 129 | //
 130 | // readable (asyncFunction)
 131 | // return a stream that calls an async function while the stream is not paused.
 132 | //
 133 | // the function must take: (count, callback) {...
 134 | //
 135 | 
 136 | es.readable =
 137 | function (func, continueOnError) {
 138 |   var stream = new Stream()
 139 |     , i = 0
 140 |     , paused = false
 141 |     , ended = false
 142 |     , reading = false
 143 | 
 144 |   stream.readable = true  
 145 |   stream.writable = false
 146 |  
 147 |   if('function' !== typeof func)
 148 |     throw new Error('event-stream.readable expects async function')
 149 |   
 150 |   stream.on('end', function () { ended = true })
 151 |   
 152 |   function get (err, data) {
 153 |     
 154 |     if(err) {
 155 |       stream.emit('error', err)
 156 |       if(!continueOnError) stream.emit('end')
 157 |     } else if (arguments.length > 1)
 158 |       stream.emit('data', data)
 159 | 
 160 |     immediately(function () {
 161 |       if(ended || paused || reading) return
 162 |       try {
 163 |         reading = true
 164 |         func.call(stream, i++, function () {
 165 |           reading = false
 166 |           get.apply(null, arguments)
 167 |         })
 168 |       } catch (err) {
 169 |         stream.emit('error', err)    
 170 |       }
 171 |     })
 172 |   }
 173 |   stream.resume = function () {
 174 |     paused = false
 175 |     get()
 176 |   }
 177 |   process.nextTick(get)
 178 |   stream.pause = function () {
 179 |      paused = true
 180 |   }
 181 |   stream.destroy = function () {
 182 |     stream.emit('end')
 183 |     stream.emit('close')
 184 |     ended = true
 185 |   }
 186 |   return stream
 187 | }
 188 | 
 189 | 
 190 | //
 191 | // map sync
 192 | //
 193 | 
 194 | es.mapSync = function (sync) { 
 195 |   return es.through(function write(data) {
 196 |     var mappedData = sync(data)
 197 |     if (typeof mappedData !== 'undefined')
 198 |       this.emit('data', mappedData)
 199 |   })
 200 | }
 201 | 
 202 | //
 203 | // log just print out what is coming through the stream, for debugging
 204 | //
 205 | 
 206 | es.log = function (name) {
 207 |   return es.through(function (data) {
 208 |     var args = [].slice.call(arguments)
 209 |     if(name) console.error(name, data)
 210 |     else     console.error(data)
 211 |     this.emit('data', data)
 212 |   })
 213 | }
 214 | 
 215 | 
 216 | //
 217 | // child -- pipe through a child process
 218 | //
 219 | 
 220 | es.child = function (child) {
 221 | 
 222 |   return es.duplex(child.stdin, child.stdout)
 223 | 
 224 | }
 225 | 
 226 | //
 227 | // parse
 228 | //
 229 | // must be used after es.split() to ensure that each chunk represents a line
 230 | // source.pipe(es.split()).pipe(es.parse())
 231 | 
 232 | es.parse = function (options) {
 233 |   var emitError = !!(options ? options.error : false)
 234 |   return es.through(function (data) {
 235 |     var obj
 236 |     try {
 237 |       if(data) //ignore empty lines
 238 |         obj = JSON.parse(data.toString())
 239 |     } catch (err) {
 240 |       if (emitError)
 241 |         return this.emit('error', err)
 242 |       return console.error(err, 'attemping to parse:', data)
 243 |     }
 244 |     //ignore lines that where only whitespace.
 245 |     if(obj !== undefined)
 246 |       this.emit('data', obj)
 247 |   })
 248 | }
 249 | //
 250 | // stringify
 251 | //
 252 | 
 253 | es.stringify = function () { 
 254 |   var Buffer = require('buffer').Buffer
 255 |   return es.mapSync(function (e){ 
 256 |     return JSON.stringify(Buffer.isBuffer(e) ? e.toString() : e) + '\n'
 257 |   }) 
 258 | }
 259 | 
 260 | //
 261 | // replace a string within a stream.
 262 | //
 263 | // warn: just concatenates the string and then does str.split().join(). 
 264 | // probably not optimal.
 265 | // for smallish responses, who cares?
 266 | // I need this for shadow-npm so it's only relatively small json files.
 267 | 
 268 | es.replace = function (from, to) {
 269 |   return es.pipeline(es.split(from), es.join(to))
 270 | } 
 271 | 
 272 | //
 273 | // join chunks with a joiner. just like Array#join
 274 | // also accepts a callback that is passed the chunks appended together
 275 | // this is still supported for legacy reasons.
 276 | // 
 277 | 
 278 | es.join = function (str) {
 279 |   
 280 |   //legacy api
 281 |   if('function' === typeof str)
 282 |     return es.wait(str)
 283 | 
 284 |   var first = true
 285 |   return es.through(function (data) {
 286 |     if(!first)
 287 |       this.emit('data', str)
 288 |     first = false
 289 |     this.emit('data', data)
 290 |     return true
 291 |   })
 292 | }
 293 | 
 294 | 
 295 | //
 296 | // wait. callback when 'end' is emitted, with all chunks appended as string.
 297 | //
 298 | 
 299 | es.wait = function (callback) {
 300 |   var arr = []
 301 |   return es.through(function (data) { arr.push(data) },
 302 |     function () {
 303 |       var body = Buffer.isBuffer(arr[0]) ? Buffer.concat(arr)
 304 |         : arr.join('')
 305 |       this.emit('data', body)
 306 |       this.emit('end')
 307 |       if(callback) callback(null, body)
 308 |     })
 309 | }
 310 | 
 311 | es.pipeable = function () {
 312 |   throw new Error('[EVENT-STREAM] es.pipeable is deprecated')
 313 | }
 314 | 
 315 | },{"buffer":undefined,"duplexer":2,"from":3,"map-stream":4,"pause-stream":5,"split":6,"stream":undefined,"stream-combiner":7,"through":8}],2:[function(require,module,exports){
 316 | var Stream = require("stream")
 317 | var writeMethods = ["write", "end", "destroy"]
 318 | var readMethods = ["resume", "pause"]
 319 | var readEvents = ["data", "close"]
 320 | var slice = Array.prototype.slice
 321 | 
 322 | module.exports = duplex
 323 | 
 324 | function forEach (arr, fn) {
 325 |     if (arr.forEach) {
 326 |         return arr.forEach(fn)
 327 |     }
 328 | 
 329 |     for (var i = 0; i < arr.length; i++) {
 330 |         fn(arr[i], i)
 331 |     }
 332 | }
 333 | 
 334 | function duplex(writer, reader) {
 335 |     var stream = new Stream()
 336 |     var ended = false
 337 | 
 338 |     forEach(writeMethods, proxyWriter)
 339 | 
 340 |     forEach(readMethods, proxyReader)
 341 | 
 342 |     forEach(readEvents, proxyStream)
 343 | 
 344 |     reader.on("end", handleEnd)
 345 | 
 346 |     writer.on("drain", function() {
 347 |       stream.emit("drain")
 348 |     })
 349 | 
 350 |     writer.on("error", reemit)
 351 |     reader.on("error", reemit)
 352 | 
 353 |     stream.writable = writer.writable
 354 |     stream.readable = reader.readable
 355 | 
 356 |     return stream
 357 | 
 358 |     function proxyWriter(methodName) {
 359 |         stream[methodName] = method
 360 | 
 361 |         function method() {
 362 |             return writer[methodName].apply(writer, arguments)
 363 |         }
 364 |     }
 365 | 
 366 |     function proxyReader(methodName) {
 367 |         stream[methodName] = method
 368 | 
 369 |         function method() {
 370 |             stream.emit(methodName)
 371 |             var func = reader[methodName]
 372 |             if (func) {
 373 |                 return func.apply(reader, arguments)
 374 |             }
 375 |             reader.emit(methodName)
 376 |         }
 377 |     }
 378 | 
 379 |     function proxyStream(methodName) {
 380 |         reader.on(methodName, reemit)
 381 | 
 382 |         function reemit() {
 383 |             var args = slice.call(arguments)
 384 |             args.unshift(methodName)
 385 |             stream.emit.apply(stream, args)
 386 |         }
 387 |     }
 388 | 
 389 |     function handleEnd() {
 390 |         if (ended) {
 391 |             return
 392 |         }
 393 |         ended = true
 394 |         var args = slice.call(arguments)
 395 |         args.unshift("end")
 396 |         stream.emit.apply(stream, args)
 397 |     }
 398 | 
 399 |     function reemit(err) {
 400 |         stream.emit("error", err)
 401 |     }
 402 | }
 403 | 
 404 | },{"stream":undefined}],3:[function(require,module,exports){
 405 | 
 406 | 'use strict';
 407 | 
 408 | var Stream = require('stream')
 409 | 
 410 | // from
 411 | //
 412 | // a stream that reads from an source.
 413 | // source may be an array, or a function.
 414 | // from handles pause behaviour for you.
 415 | 
 416 | module.exports =
 417 | function from (source) {
 418 |   if(Array.isArray(source)) {
 419 |     source = source.slice()
 420 |     return from (function (i) {
 421 |       if(source.length)
 422 |         this.emit('data', source.shift())
 423 |       else
 424 |         this.emit('end')
 425 |       return true
 426 |     })
 427 |   }
 428 |   var s = new Stream(), i = 0
 429 |   s.ended = false
 430 |   s.started = false
 431 |   s.readable = true
 432 |   s.writable = false
 433 |   s.paused = false
 434 |   s.ended = false
 435 |   s.pause = function () {
 436 |     s.started = true
 437 |     s.paused = true
 438 |   }
 439 |   function next () {
 440 |     s.started = true
 441 |     if(s.ended) return
 442 |     while(!s.ended && !s.paused && source.call(s, i++, function () {
 443 |       if(!s.ended && !s.paused)
 444 |           next()
 445 |     }))
 446 |       ;
 447 |   }
 448 |   s.resume = function () {
 449 |     s.started = true
 450 |     s.paused = false
 451 |     next()
 452 |   }
 453 |   s.on('end', function () {
 454 |     s.ended = true
 455 |     s.readable = false
 456 |     process.nextTick(s.destroy)
 457 |   })
 458 |   s.destroy = function () {
 459 |     s.ended = true
 460 |     s.emit('close') 
 461 |   }
 462 |   /*
 463 |     by default, the stream will start emitting at nextTick
 464 |     if you want, you can pause it, after pipeing.
 465 |     you can also resume before next tick, and that will also
 466 |     work.
 467 |   */
 468 |   process.nextTick(function () {
 469 |     if(!s.started) s.resume()
 470 |   })
 471 |   return s
 472 | }
 473 | 
 474 | },{"stream":undefined}],4:[function(require,module,exports){
 475 | //filter will reemit the data if cb(err,pass) pass is truthy
 476 | 
 477 | // reduce is more tricky
 478 | // maybe we want to group the reductions or emit progress updates occasionally
 479 | // the most basic reduce just emits one 'data' event after it has recieved 'end'
 480 | 
 481 | 
 482 | var Stream = require('stream').Stream
 483 | 
 484 | 
 485 | //create an event stream and apply function to each .write
 486 | //emitting each response as data
 487 | //unless it's an empty callback
 488 | 
 489 | module.exports = function (mapper, opts) {
 490 | 
 491 |   var stream = new Stream()
 492 |     , self = this
 493 |     , inputs = 0
 494 |     , outputs = 0
 495 |     , ended = false
 496 |     , paused = false
 497 |     , destroyed = false
 498 |     , lastWritten = 0
 499 |     , inNext = false
 500 | 
 501 |   this.opts = opts || {};
 502 |   var errorEventName = this.opts.failures ? 'failure' : 'error';
 503 | 
 504 |   // Items that are not ready to be written yet (because they would come out of
 505 |   // order) get stuck in a queue for later.
 506 |   var writeQueue = {}
 507 | 
 508 |   stream.writable = true
 509 |   stream.readable = true
 510 | 
 511 |   function queueData (data, number) {
 512 |     var nextToWrite = lastWritten + 1
 513 | 
 514 |     if (number === nextToWrite) {
 515 |       // If it's next, and its not undefined write it
 516 |       if (data !== undefined) {
 517 |         stream.emit.apply(stream, ['data', data])
 518 |       }
 519 |       lastWritten ++
 520 |       nextToWrite ++
 521 |     } else {
 522 |       // Otherwise queue it for later.
 523 |       writeQueue[number] = data
 524 |     }
 525 | 
 526 |     // If the next value is in the queue, write it
 527 |     if (writeQueue.hasOwnProperty(nextToWrite)) {
 528 |       var dataToWrite = writeQueue[nextToWrite]
 529 |       delete writeQueue[nextToWrite]
 530 |       return queueData(dataToWrite, nextToWrite)
 531 |     }
 532 | 
 533 |     outputs ++
 534 |     if(inputs === outputs) {
 535 |       if(paused) paused = false, stream.emit('drain') //written all the incoming events
 536 |       if(ended) end()
 537 |     }
 538 |   }
 539 | 
 540 |   function next (err, data, number) {
 541 |     if(destroyed) return
 542 |     inNext = true
 543 | 
 544 |     if (!err || self.opts.failures) {
 545 |       queueData(data, number)
 546 |     }
 547 | 
 548 |     if (err) {
 549 |       stream.emit.apply(stream, [ errorEventName, err ]);
 550 |     }
 551 | 
 552 |     inNext = false;
 553 |   }
 554 | 
 555 |   // Wrap the mapper function by calling its callback with the order number of
 556 |   // the item in the stream.
 557 |   function wrappedMapper (input, number, callback) {
 558 |     return mapper.call(null, input, function(err, data){
 559 |       callback(err, data, number)
 560 |     })
 561 |   }
 562 | 
 563 |   stream.write = function (data) {
 564 |     if(ended) throw new Error('map stream is not writable')
 565 |     inNext = false
 566 |     inputs ++
 567 | 
 568 |     try {
 569 |       //catch sync errors and handle them like async errors
 570 |       var written = wrappedMapper(data, inputs, next)
 571 |       paused = (written === false)
 572 |       return !paused
 573 |     } catch (err) {
 574 |       //if the callback has been called syncronously, and the error
 575 |       //has occured in an listener, throw it again.
 576 |       if(inNext)
 577 |         throw err
 578 |       next(err)
 579 |       return !paused
 580 |     }
 581 |   }
 582 | 
 583 |   function end (data) {
 584 |     //if end was called with args, write it, 
 585 |     ended = true //write will emit 'end' if ended is true
 586 |     stream.writable = false
 587 |     if(data !== undefined) {
 588 |       return queueData(data, inputs)
 589 |     } else if (inputs == outputs) { //wait for processing 
 590 |       stream.readable = false, stream.emit('end'), stream.destroy() 
 591 |     }
 592 |   }
 593 | 
 594 |   stream.end = function (data) {
 595 |     if(ended) return
 596 |     end()
 597 |   }
 598 | 
 599 |   stream.destroy = function () {
 600 |     ended = destroyed = true
 601 |     stream.writable = stream.readable = paused = false
 602 |     process.nextTick(function () {
 603 |       stream.emit('close')
 604 |     })
 605 |   }
 606 |   stream.pause = function () {
 607 |     paused = true
 608 |   }
 609 | 
 610 |   stream.resume = function () {
 611 |     paused = false
 612 |   }
 613 | 
 614 |   return stream
 615 | }
 616 | 
 617 | 
 618 | 
 619 | 
 620 | 
 621 | },{"stream":undefined}],5:[function(require,module,exports){
 622 | //through@2 handles this by default!
 623 | module.exports = require('through')
 624 | 
 625 | 
 626 | },{"through":8}],6:[function(require,module,exports){
 627 | //filter will reemit the data if cb(err,pass) pass is truthy
 628 | 
 629 | // reduce is more tricky
 630 | // maybe we want to group the reductions or emit progress updates occasionally
 631 | // the most basic reduce just emits one 'data' event after it has recieved 'end'
 632 | 
 633 | 
 634 | var through = require('through')
 635 | var Decoder = require('string_decoder').StringDecoder
 636 | 
 637 | module.exports = split
 638 | 
 639 | //TODO pass in a function to map across the lines.
 640 | 
 641 | function split (matcher, mapper, options) {
 642 |   var decoder = new Decoder()
 643 |   var soFar = ''
 644 |   var maxLength = options && options.maxLength;
 645 |   if('function' === typeof matcher)
 646 |     mapper = matcher, matcher = null
 647 |   if (!matcher)
 648 |     matcher = /\r?\n/
 649 | 
 650 |   function emit(stream, piece) {
 651 |     if(mapper) {
 652 |       try {
 653 |         piece = mapper(piece)
 654 |       }
 655 |       catch (err) {
 656 |         return stream.emit('error', err)
 657 |       }
 658 |       if('undefined' !== typeof piece)
 659 |         stream.queue(piece)
 660 |     }
 661 |     else
 662 |       stream.queue(piece)
 663 |   }
 664 | 
 665 |   function next (stream, buffer) {
 666 |     var pieces = ((soFar != null ? soFar : '') + buffer).split(matcher)
 667 |     soFar = pieces.pop()
 668 | 
 669 |     if (maxLength && soFar.length > maxLength)
 670 |       stream.emit('error', new Error('maximum buffer reached'))
 671 | 
 672 |     for (var i = 0; i < pieces.length; i++) {
 673 |       var piece = pieces[i]
 674 |       emit(stream, piece)
 675 |     }
 676 |   }
 677 | 
 678 |   return through(function (b) {
 679 |     next(this, decoder.write(b))
 680 |   },
 681 |   function () {
 682 |     if(decoder.end)
 683 |       next(this, decoder.end())
 684 |     if(soFar != null)
 685 |       emit(this, soFar)
 686 |     this.queue(null)
 687 |   })
 688 | }
 689 | 
 690 | 
 691 | },{"string_decoder":undefined,"through":8}],7:[function(require,module,exports){
 692 | var duplexer = require('duplexer')
 693 | 
 694 | module.exports = function () {
 695 | 
 696 |   var streams = [].slice.call(arguments)
 697 |     , first = streams[0]
 698 |     , last = streams[streams.length - 1]
 699 |     , thepipe = duplexer(first, last)
 700 | 
 701 |   if(streams.length == 1)
 702 |     return streams[0]
 703 |   else if (!streams.length)
 704 |     throw new Error('connect called with empty args')
 705 | 
 706 |   //pipe all the streams together
 707 | 
 708 |   function recurse (streams) {
 709 |     if(streams.length < 2)
 710 |       return
 711 |     streams[0].pipe(streams[1])
 712 |     recurse(streams.slice(1))  
 713 |   }
 714 |   
 715 |   recurse(streams)
 716 |  
 717 |   function onerror () {
 718 |     var args = [].slice.call(arguments)
 719 |     args.unshift('error')
 720 |     thepipe.emit.apply(thepipe, args)
 721 |   }
 722 |   
 723 |   //es.duplex already reemits the error from the first and last stream.
 724 |   //add a listener for the inner streams in the pipeline.
 725 |   for(var i = 1; i < streams.length - 1; i ++)
 726 |     streams[i].on('error', onerror)
 727 | 
 728 |   return thepipe
 729 | }
 730 | 
 731 | 
 732 | },{"duplexer":2}],8:[function(require,module,exports){
 733 | var Stream = require('stream')
 734 | 
 735 | // through
 736 | //
 737 | // a stream that does nothing but re-emit the input.
 738 | // useful for aggregating a series of changing but not ending streams into one stream)
 739 | 
 740 | exports = module.exports = through
 741 | through.through = through
 742 | 
 743 | //create a readable writable stream.
 744 | 
 745 | function through (write, end, opts) {
 746 |   write = write || function (data) { this.queue(data) }
 747 |   end = end || function () { this.queue(null) }
 748 | 
 749 |   var ended = false, destroyed = false, buffer = [], _ended = false
 750 |   var stream = new Stream()
 751 |   stream.readable = stream.writable = true
 752 |   stream.paused = false
 753 | 
 754 | //  stream.autoPause   = !(opts && opts.autoPause   === false)
 755 |   stream.autoDestroy = !(opts && opts.autoDestroy === false)
 756 | 
 757 |   stream.write = function (data) {
 758 |     write.call(this, data)
 759 |     return !stream.paused
 760 |   }
 761 | 
 762 |   function drain() {
 763 |     while(buffer.length && !stream.paused) {
 764 |       var data = buffer.shift()
 765 |       if(null === data)
 766 |         return stream.emit('end')
 767 |       else
 768 |         stream.emit('data', data)
 769 |     }
 770 |   }
 771 | 
 772 |   stream.queue = stream.push = function (data) {
 773 | //    console.error(ended)
 774 |     if(_ended) return stream
 775 |     if(data === null) _ended = true
 776 |     buffer.push(data)
 777 |     drain()
 778 |     return stream
 779 |   }
 780 | 
 781 |   //this will be registered as the first 'end' listener
 782 |   //must call destroy next tick, to make sure we're after any
 783 |   //stream piped from here.
 784 |   //this is only a problem if end is not emitted synchronously.
 785 |   //a nicer way to do this is to make sure this is the last listener for 'end'
 786 | 
 787 |   stream.on('end', function () {
 788 |     stream.readable = false
 789 |     if(!stream.writable && stream.autoDestroy)
 790 |       process.nextTick(function () {
 791 |         stream.destroy()
 792 |       })
 793 |   })
 794 | 
 795 |   function _end () {
 796 |     stream.writable = false
 797 |     end.call(stream)
 798 |     if(!stream.readable && stream.autoDestroy)
 799 |       stream.destroy()
 800 |   }
 801 | 
 802 |   stream.end = function (data) {
 803 |     if(ended) return
 804 |     ended = true
 805 |     if(arguments.length) stream.write(data)
 806 |     _end() // will emit or queue
 807 |     return stream
 808 |   }
 809 | 
 810 |   stream.destroy = function () {
 811 |     if(destroyed) return
 812 |     destroyed = true
 813 |     ended = true
 814 |     buffer.length = 0
 815 |     stream.writable = stream.readable = false
 816 |     stream.emit('close')
 817 |     return stream
 818 |   }
 819 | 
 820 |   stream.pause = function () {
 821 |     if(stream.paused) return
 822 |     stream.paused = true
 823 |     return stream
 824 |   }
 825 | 
 826 |   stream.resume = function () {
 827 |     if(stream.paused) {
 828 |       stream.paused = false
 829 |       stream.emit('resume')
 830 |     }
 831 |     drain()
 832 |     //may have become paused again,
 833 |     //as drain emits 'data'.
 834 |     if(!stream.paused)
 835 |       stream.emit('drain')
 836 |     return stream
 837 |   }
 838 |   return stream
 839 | }
 840 | 
 841 | 
 842 | },{"stream":undefined}],9:[function(require,module,exports){
 843 | var through = require('through');
 844 | 
 845 | module.exports = ReplaceStream;
 846 | function ReplaceStream(search, replace, options) {
 847 |   var tail = '';
 848 |   var totalMatches = 0;
 849 |   var isRegex = search instanceof RegExp;
 850 | 
 851 |   options = options || {};
 852 |   options.limit = options.limit || Infinity;
 853 |   options.encoding = options.encoding || 'utf8';
 854 |   options.max_match_len = options.max_match_len || 100;
 855 | 
 856 |   var replaceFn = replace;
 857 | 
 858 |   replaceFn = createReplaceFn(replace, isRegex);
 859 | 
 860 |   var match;
 861 |   if (isRegex) {
 862 |     match = matchFromRegex(search, options)
 863 |   } else {
 864 |     match = matchFromString(search, options);
 865 |     options.max_match_len = search.length;
 866 |   }
 867 | 
 868 |   function write(buf) {
 869 |     var matches;
 870 |     var lastPos = 0;
 871 |     var runningMatch = '';
 872 |     var matchCount = 0;
 873 |     var rewritten = '';
 874 |     var haystack = tail + buf.toString(options.encoding);
 875 |     tail = '';
 876 | 
 877 |     while (totalMatches < options.limit &&
 878 |           (matches = match.exec(haystack)) !== null) {
 879 | 
 880 |       matchCount++;
 881 |       var before = haystack.slice(lastPos, matches.index);
 882 |       var regexMatch = matches;
 883 |       lastPos = matches.index + regexMatch[0].length;
 884 | 
 885 |       if (lastPos > haystack.length && regexMatch[0].length < options.max_match_len) {
 886 |         tail = regexMatch[0]
 887 |       } else {
 888 |         var dataToAppend = getDataToAppend(before,regexMatch);
 889 |         rewritten += dataToAppend;
 890 |       }
 891 |     }
 892 | 
 893 |     if (tail.length < 1)
 894 |       tail = haystack.slice(lastPos) > options.max_match_len ? haystack.slice(lastPos).slice(0 - options.max_match_len) : haystack.slice(lastPos)
 895 | 
 896 |     var dataToQueue = getDataToQueue(matchCount,haystack,rewritten,lastPos);
 897 |     this.queue(dataToQueue);
 898 |   }
 899 | 
 900 |   function getDataToAppend(before, match) {
 901 |     var dataToAppend = before;
 902 | 
 903 |     totalMatches++;
 904 | 
 905 |     dataToAppend += isRegex ? replaceFn.apply(this, match.concat([match.index, match.input])) : replaceFn(match[0]);
 906 | 
 907 |     return dataToAppend;
 908 |   }
 909 | 
 910 |   function getDataToQueue(matchCount, haystack, rewritten, lastPos) {
 911 |     var dataToQueue;
 912 | 
 913 |     if (matchCount > 0) {
 914 |       if (haystack.length > tail.length) {
 915 |         dataToQueue = rewritten + haystack.slice(lastPos, haystack.length - tail.length)
 916 |       } else {
 917 |         dataToQueue = rewritten
 918 |       }
 919 |     } else {
 920 |       dataToQueue = haystack.slice(0, haystack.length - tail.length)
 921 |     }
 922 | 
 923 |     return dataToQueue;
 924 |   }
 925 | 
 926 |   function end() {
 927 |     if (tail) this.queue(tail);
 928 |     this.queue(null);
 929 |   }
 930 | 
 931 |   var t = through(write, end);
 932 |   return t;
 933 | }
 934 | 
 935 | function createReplaceFn(replace, isRegEx) {
 936 |   var regexReplaceFunction = function () {
 937 |     var newReplace = replace;
 938 |     // ability to us $1 with captures
 939 |     // Start at 1 and end at length - 2 to avoid the match parameter and offset
 940 |     // And string parameters
 941 |     var paramLength = arguments.length - 2;
 942 |     for (var i = 1; i < paramLength; i++) {
 943 |       newReplace = newReplace.replace('$' + i, arguments[i] || '')
 944 |     }
 945 |     return newReplace;
 946 |   };
 947 | 
 948 |   var stringReplaceFunction = function () {
 949 |     return replace;
 950 |   };
 951 | 
 952 |   if (isRegEx && !(replace instanceof Function)) {
 953 |     return regexReplaceFunction;
 954 |   }
 955 | 
 956 |   if (!(replace instanceof Function)) {
 957 |     return stringReplaceFunction
 958 |   }
 959 | 
 960 |   return replace
 961 | }
 962 | 
 963 | function escapeRegExp(s) {
 964 |     return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
 965 | }
 966 | 
 967 | function matchFromRegex(s, options) {
 968 |   var regex = s
 969 |   if (options.regExpOptions)
 970 |     regex = new RegExp(s.source, options.regExpOptions)
 971 | 
 972 |   // If there is no global flag then there can only be one match
 973 |   if (!regex.global) {
 974 |     options.limit = 1;
 975 |   }
 976 |   return regex
 977 | }
 978 | 
 979 | function matchFromString(s, options) {
 980 |   if (options.regExpOptions)
 981 |     return new RegExp(escapeRegExp(s), options.regExpOptions)
 982 | 
 983 |   return new RegExp(escapeRegExp(s), options.ignoreCase === false ? 'gm' : 'gmi')
 984 | }
 985 | 
 986 | },{"through":10}],10:[function(require,module,exports){
 987 | arguments[4][8][0].apply(exports,arguments)
 988 | },{"dup":8,"stream":undefined}],11:[function(require,module,exports){
 989 | var path = require('path');
 990 | var fs = require('fs');
 991 | var https = require('https');
 992 | var replacestream = require('replacestream');
 993 | var through = require('event-stream').through;
 994 | 
 995 | var clientUrl = 'https://static.opentok.com/VERSION/js/opentok.js';
 996 | 
 997 | // Fetch OpenTok.js client
 998 | // This script will run once per platform where the hook is applied
 999 | // Acknowledgement: This script was inspired by original work from Callan Iwan Kandasamy
1000 | // (https://github.com/CallanIwan), contained in
1001 | // https://github.com/songz/cordova-plugin-opentok/pull/176
1002 | 
1003 | // TODO: make a separate script that can be run to update the library after the plugin is installed
1004 | module.exports = function(context) {
1005 | 
1006 |   var Q = context.requireCordovaModule('q');
1007 |   var osenv = context.requireCordovaModule('osenv');
1008 |   var ConfigParser = context.requireCordovaModule('../configparser/ConfigParser');
1009 | 
1010 |   var deferral = Q.defer();
1011 | 
1012 |   var config = new ConfigParser(path.join(context.opts.projectRoot, 'config.xml'));
1013 |   var opentokClientVersion =
1014 |     config.getPreference('OpentokClientVersion', context.opts.plugin.platform) || 'v2';
1015 | 
1016 |   var modulePath =
1017 |     path.join(context.opts.plugin.dir, 'src', context.opts.plugin.platform, 'opentok.js');
1018 | 
1019 |   // TODO: error handling
1020 |   var moduleWriteStream = fs.createWriteStream(modulePath);
1021 |   moduleWriteStream.on('open', function() {
1022 |     https.get(clientUrl.replace('VERSION', opentokClientVersion), function(res) {
1023 |       var sourceStream = res.pipe(replacestream(/if \(location\.protocol === 'file:'\) {[^}]*}/gm, '/* removed by cordova-plugin-opentokjs */', {
1024 |         max_match_len: 1000
1025 |       }));
1026 | 
1027 |       if (context.opts.plugin.platform === 'ios') {
1028 |         sourceStream = sourceStream.pipe(replacestream('var isSupported = $.env.name === \'Safari\' ||\n                  ($.env.name === \'IE\' && $.env.version >= 8 &&', 'var isSupported =  ($.env.name === \'IE\' && $.env.version >= 8 &&', {
1029 |           max_match_len: 1000
1030 |         }))
1031 |         .pipe(replacestream('loadedEvent = webRtcStream.getVideoTracks().length > minVideoTracksForTimeUpdate ?\n          \'timeupdate\' : \'loadedmetadata\';', 'loadedEvent = \'loadedmetadata\';', {
1032 |           max_match_len: 1000
1033 |         }))
1034 |         .pipe(replacestream('onError = function onError (event) {\n          cleanup();\n          unbindNativeStream(videoElement);\n', 'onError = function onError (event) {\n          if (event.target.error.code === window.MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED) {\n            return onLoad();\n          }\n          cleanup();\n          unbindNativeStream(videoElement);\n', {
1035 |           max_match_len: 1000
1036 |         }))
1037 |         .pipe(replacestream('var _onVideoError = OT.$.bind(function(event) {\n', 'var _onVideoError = OT.$.bind(function(event) {\n          if (event.target.error.code === window.MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED) {\n            return;\n          }\n', {
1038 |           max_match_len: 1000
1039 |         }));
1040 |       }
1041 | 
1042 |       sourceStream.pipe(through(
1043 |         function write(data) {
1044 |           this.emit('data', data);
1045 |         },
1046 | 
1047 |         function end() {
1048 |           this.emit('data', '\n// cordova-plugin-opentok injected export\nmodule.exports = window.OT;\n');
1049 |           this.emit('end');
1050 |         }))
1051 |       .pipe(moduleWriteStream)
1052 |       .on('finish', function() {
1053 |         deferral.resolve();
1054 |       });
1055 |     });
1056 |   });
1057 | 
1058 |   return deferral.promise;
1059 | };
1060 | 
1061 | },{"event-stream":1,"fs":undefined,"https":undefined,"path":undefined,"replacestream":9}]},{},[11])(11)
1062 | });


--------------------------------------------------------------------------------
/src/android/OpenTokPlugin.java:
--------------------------------------------------------------------------------
 1 | package me.aoberoi.cordova.opentokjs;
 2 | 
 3 | import org.apache.cordova.CordovaPlugin;
 4 | import org.apache.cordova.CallbackContext;
 5 | 
 6 | import org.json.JSONArray;
 7 | import org.json.JSONException;
 8 | import org.json.JSONObject;
 9 | 
10 | /**
11 |  * This class echoes a string called from JavaScript.
12 |  */
13 | public class OpenTokPlugin extends CordovaPlugin {
14 | 
15 |     @Override
16 |     public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
17 |         if (action.equals("coolMethod")) {
18 |             String message = args.getString(0);
19 |             this.coolMethod(message, callbackContext);
20 |             return true;
21 |         }
22 |         return false;
23 |     }
24 | 
25 |     private void coolMethod(String message, CallbackContext callbackContext) {
26 |         if (message != null && message.length() > 0) {
27 |             callbackContext.success(message);
28 |         } else {
29 |             callbackContext.error("Expected one non-empty string argument.");
30 |         }
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/browser/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aoberoi/cordova-plugin-opentokjs/fbcbc3ae44ba6459e97450cad2913424c55ed334/src/browser/.gitkeep


--------------------------------------------------------------------------------
/src/ios/OpenTokPlugin.m:
--------------------------------------------------------------------------------
 1 | /********* OpenTokPlugin.m Cordova Plugin Implementation *******/
 2 | 
 3 | #import <Cordova/CDV.h>
 4 | 
 5 | @interface OpenTokPlugin : CDVPlugin {
 6 |   // Member variables go here.
 7 | }
 8 | 
 9 | - (void)coolMethod:(CDVInvokedUrlCommand*)command;
10 | @end
11 | 
12 | @implementation OpenTokPlugin
13 | 
14 | - (void)coolMethod:(CDVInvokedUrlCommand*)command
15 | {
16 |     CDVPluginResult* pluginResult = nil;
17 |     NSString* echo = [command.arguments objectAtIndex:0];
18 | 
19 |     if (echo != nil && [echo length] > 0) {
20 |         pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_OK messageAsString:echo];
21 |     } else {
22 |         pluginResult = [CDVPluginResult resultWithStatus:CDVCommandStatus_ERROR];
23 |     }
24 | 
25 |     [self.commandDelegate sendPluginResult:pluginResult callbackId:command.callbackId];
26 | }
27 | 
28 | @end
29 | 


--------------------------------------------------------------------------------