@sawa-siemens/socket.io-stream 0.10.0

package/.nvmrc

@@ -0,0 +1 @@
+v20.19.4

package/.travis.yml

@@ -0,0 +1,28 @@
+language: node_js
+install:
+  - npm install
+  - make install
+node_js:
+  - 0.10
+  - 0.12
+  - 4.2
+sudo: false
+env:
+  global:
+    - secure: BOJOcmv3/8m1e2W7c4MStir5VraXxCeXlslW1xg926FUFry4kayWJhG9FD9GzWopVpeERAHPvr63pou7ylp7m2lkt1zUnacicKdTtXrdSlq2518LasnGJSxfFB59JOTdmdHn/gBAZKrhLTtsYw+mU6AanctXE/NyCVsSZXAig1Y=
+    - secure: JoPDfwbrYEKY96XjVc59SSZ/cJ7ll2Vj2vmXqVk0yIwQiJdoXEHg3vwgZRPyCztwXlkjyQsLSLuJN1LSA/b04V8UdreAIILIbSazpQFDjH2ize18v6EVtyvP1PbQoicOsbLON8GdZGfP4kCJ4VNdr8JWLlpHS2Ef/Y0eCIQOxN0=
+  matrix:
+    - SOCKETIO_VERSION=
+    - SOCKETIO_VERSION=0.9
+matrix:
+  include:
+  - node_js: 0.12
+    env: BROWSER_NAME=chrome BROWSER_VERSION=latest
+  - node_js: 0.12
+    env: BROWSER_NAME=safari BROWSER_VERSION=latest
+  - node_js: 0.12
+    env: BROWSER_NAME=ie BROWSER_VERSION=latest
+  - node_js: 0.12
+    env: BROWSER_NAME=iphone BROWSER_VERSION=9.0
+  - node_js: 0.12
+    env: BROWSER_NAME=android BROWSER_VERSION=5.1

package/.zuul.yml

@@ -0,0 +1,6 @@
+ui: mocha-bdd
+server: ./test/support/server.js
+tunnel:
+  type: ngrok
+  authtoken: XP5uKk4Sm6C5XfdTZozb
+  proto: tcp

package/LICENSE

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

package/README.md

@@ -0,0 +1,219 @@
+# Socket.IO stream
+
+[![Build Status](https://travis-ci.org/nkzawa/socket.io-stream.png?branch=master)](https://travis-ci.org/nkzawa/socket.io-stream)
+[![NPM version](https://badge.fury.io/js/socket.io-stream.png)](http://badge.fury.io/js/socket.io-stream)
+
+This is the module for bidirectional binary data transfer with Stream API through [Socket.IO](https://github.com/socketio/socket.io).
+
+## Installation
+
+    npm install socket.io-stream
+
+## Usage
+
+If you are not familiar with Stream API, be sure to check out [the docs](http://nodejs.org/api/stream.html).
+I also recommend checking out the awesome [Stream Handbook](https://github.com/substack/stream-handbook).
+
+For streaming between server and client, you will send stream instances first.
+To receive streams, you just wrap `socket` with `socket.io-stream`, then listen any events as usual.
+
+Server:
+
+```js
+var io = require('socket.io').listen(80);
+var ss = require('socket.io-stream');
+var path = require('path');
+
+io.of('/user').on('connection', function(socket) {
+  ss(socket).on('profile-image', function(stream, data) {
+    var filename = path.basename(data.name);
+    stream.pipe(fs.createWriteStream(filename));
+  });
+});
+```
+
+`createStream()` returns a new stream which can be sent by `emit()`.
+
+Client:
+
+```js
+var io = require('socket.io-client');
+var ss = require('socket.io-stream');
+
+var socket = io.connect('http://example.com/user');
+var stream = ss.createStream();
+var filename = 'profile.jpg';
+
+ss(socket).emit('profile-image', stream, {name: filename});
+fs.createReadStream(filename).pipe(stream);
+```
+
+You can stream data from a client to server, and vice versa.
+
+```js
+// send data
+ss(socket).on('file', function(stream) {
+  fs.createReadStream('/path/to/file').pipe(stream);
+});
+
+// receive data
+ss(socket).emit('file', stream);
+stream.pipe(fs.createWriteStream('file.txt'));
+```
+
+### Browser
+
+This module can be used on the browser. To do so, just copy a file to a public directory.
+
+    $ cp node_modules/socket.io-stream/socket.io-stream.js somewhere/public/
+
+You can also use [browserify](http://github.com/substack/node-browserify) to create your own bundle.
+
+    $ npm install browserify -g
+    $ cd node_modules/socket.io-stream
+    $ browserify index.js -s ss > socket.io-stream.js
+
+```html
+<input id="file" type="file" />
+
+<script src="/socket.io/socket.io.js"></script>
+<script src="/js/socket.io-stream.js"></script>
+<script src="/js/jquery.js"></script>
+<script>
+$(function() {
+  var socket = io.connect('/foo');
+
+  $('#file').change(function(e) {
+    var file = e.target.files[0];
+    var stream = ss.createStream();
+
+    // upload a file to the server.
+    ss(socket).emit('file', stream, {size: file.size});
+    ss.createBlobReadStream(file).pipe(stream);
+  });
+});
+</script>
+```
+
+#### Upload progress
+
+You can track upload progress like the following:
+
+```js
+var blobStream = ss.createBlobReadStream(file);
+var size = 0;
+
+blobStream.on('data', function(chunk) {
+  size += chunk.length;
+  console.log(Math.floor(size / file.size * 100) + '%');
+  // -> e.g. '42%'
+});
+
+blobStream.pipe(stream);
+```
+
+### Socket.IO v0.9 support
+
+You have to set `forceBase64` option `true` when using the library with socket.io v0.9.x.
+
+```js
+ss.forceBase64 = true;
+```
+
+
+## Documentation
+
+### ss(sio)
+
+- sio `socket.io Socket` A socket of Socket.IO, both for client and server
+- return `Socket`
+
+Look up an existing `Socket` instance based on `sio` (a socket of Socket.IO), or create one if it doesn't exist.
+
+### socket.emit(event, [arg1], [arg2], [...])
+
+- event `String` The event name
+
+Emit an `event` with variable number of arguments including at least a stream.
+
+```js
+ss(socket).emit('myevent', stream, {name: 'thefilename'}, function() { ... });
+
+// send some streams at a time.
+ss(socket).emit('multiple-streams', stream1, stream2);
+
+// as members of array or object.
+ss(socket).emit('flexible', [stream1, { foo: stream2 }]);
+
+// get streams through the ack callback
+ss(socket).emit('ack', function(stream1, stream2) { ... });
+```
+
+### socket.on(event, listener)
+
+- event `String` The event name
+- listener `Function` The event handler function
+
+Add a `listener` for `event`. `listener` will take stream(s) with any data as arguments.
+
+```js
+ss(socket).on('myevent', function(stream, data, callback) { ... });
+
+// access stream options
+ss(socket).on('foo', function(stream) {
+  if (stream.options && stream.options.highWaterMark > 1024) {
+    console.error('Too big highWaterMark.');
+    return;
+  }
+});
+```
+
+### ss.createStream([options])
+
+- options `Object`
+    - highWaterMark `Number`
+    - encoding `String`
+    - decodeStrings `Boolean`
+    - objectMode `Boolean`
+    - allowHalfOpen `Boolean` if `true`, then the stream won't automatically close when the other endpoint ends. Default to `false`.
+- return `Duplex Stream`
+
+Create a new duplex stream. See [the docs](http://nodejs.org/api/stream.html) for the details of stream and `options`.
+
+```js
+var stream = ss.createStream();
+
+// with options
+var stream = ss.createStream({
+  highWaterMark: 1024,
+  objectMode: true,
+  allowHalfOpen: true
+});
+```
+
+### ss.createBlobReadStream(blob, [options])
+
+- options `Object`
+    - highWaterMark `Number`
+    - encoding `String`
+    - objectMode `Boolean`
+- return `Readable Stream`
+
+Create a new readable stream for [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob) and [File](https://developer.mozilla.org/en-US/docs/Web/API/File) on browser. See [the docs](http://nodejs.org/api/stream.html) for the details of stream and `options`.
+
+```js
+var stream = ss.createBlobReadStream(new Blob([1, 2, 3]));
+```
+
+### ss.Buffer
+
+[Node Buffer](https://nodejs.org/api/buffer.html) class to use on browser, which is exposed for convenience. On Node environment, you should just use normal `Buffer`.
+
+```js
+var stream = ss.createStream();
+stream.write(new ss.Buffer([0, 1, 2]));
+```
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,236 @@
+/// <reference types="node" />
+
+import { EventEmitter } from 'events';
+import { Duplex, Readable, DuplexOptions } from 'stream';
+
+/**
+ * Socket.IO socket interface (compatible with both server and client sockets)
+ */
+export interface SocketIOSocketLike {
+  on(event: string, callback: (...args: any[]) => void): this;
+  emit(event: string, ...args: any[]): this;
+  _streamSocket?: any; // Socket instance (using any to avoid circular reference)
+}
+
+/**
+ * Options for creating a Socket instance
+ */
+export interface SocketOptions {
+  /**
+   * Forces base 64 encoding when emitting. Must be set to true for Socket.IO v0.9 or lower.
+   * @default false
+   */
+  forceBase64?: boolean;
+}
+
+/**
+ * Options for creating an IOStream
+ */
+export interface IOStreamOptions extends DuplexOptions {
+  /**
+   * Allow half-open sockets. If set to false, then the stream will automatically
+   * end the writable side when the readable side ends.
+   * @default false
+   */
+  allowHalfOpen?: boolean;
+}
+
+/**
+ * Options for creating a BlobReadStream
+ */
+export interface BlobReadStreamOptions {
+  /**
+   * Use synchronous FileReader API
+   * @default false
+   */
+  synchronous?: boolean;
+  highWaterMark?: number;
+}
+
+/**
+ * Bidirectional stream socket which wraps Socket.IO.
+ * Extends EventEmitter and provides stream-based communication over Socket.IO.
+ */
+export class Socket extends EventEmitter {
+  /**
+   * Base event name for messaging.
+   */
+  static readonly event: string;
+
+  /**
+   * List of events that are handled directly by EventEmitter.
+   */
+  static readonly events: string[];
+
+  /**
+   * The underlying Socket.IO socket instance.
+   */
+  readonly sio: SocketIOSocketLike;
+
+  /**
+   * Whether to force base64 encoding.
+   */
+  readonly forceBase64: boolean;
+
+  /**
+   * Creates a new Socket instance.
+   * @param sio - Socket.IO socket instance (server or client)
+   * @param options - Socket options
+   */
+  constructor(sio: SocketIOSocketLike, options?: SocketOptions);
+
+  /**
+   * Emits streams to the corresponding server/client.
+   * @param type - Event type
+   * @param args - Additional arguments, which may include IOStream instances
+   * @returns This Socket instance for chaining
+   */
+  emit(type: string, ...args: any[]): this;
+
+  /**
+   * Listens for stream events.
+   * @param type - Event type
+   * @param listener - Event listener function that receives streams and other arguments
+   * @returns This Socket instance for chaining
+   */
+  on(type: string, listener: (...args: any[]) => void): this;
+
+  /**
+   * Listens for stream events (one-time).
+   * @param type - Event type
+   * @param listener - Event listener function that receives streams and other arguments
+   * @returns This Socket instance for chaining
+   */
+  once(type: string, listener: (...args: any[]) => void): this;
+
+  /**
+   * Removes a listener for stream events.
+   * @param type - Event type
+   * @param listener - Event listener function
+   * @returns This Socket instance for chaining
+   */
+  removeListener(type: string, listener: (...args: any[]) => void): this;
+
+  /**
+   * Removes all listeners for a specific event type.
+   * @param type - Event type
+   * @returns This Socket instance for chaining
+   */
+  removeAllListeners(type?: string): this;
+
+  /**
+   * Cleans up a stream by its ID.
+   * @param id - Stream ID
+   */
+  cleanup(id: string): void;
+}
+
+/**
+ * Duplex stream for Socket.IO communication.
+ * Extends Node.js Duplex stream and can be used for bidirectional data transfer.
+ */
+export class IOStream extends Duplex {
+  /**
+   * Unique identifier for this stream.
+   */
+  readonly id: string;
+
+  /**
+   * The Socket instance this stream is associated with.
+   */
+  socket: Socket | null;
+
+  /**
+   * Whether this stream has been destroyed.
+   */
+  readonly destroyed: boolean;
+
+  /**
+   * Options passed during construction.
+   */
+  readonly options?: IOStreamOptions;
+
+  /**
+   * Creates a new IOStream instance.
+   * @param options - Stream options
+   */
+  constructor(options?: IOStreamOptions);
+
+  /**
+   * Ensures that no more I/O activity happens on this stream.
+   * Not necessary in the usual case.
+   */
+  destroy(): void;
+}
+
+/**
+ * Readable stream for Blob and File objects on the browser.
+ * Extends Node.js Readable stream.
+ */
+export class BlobReadStream extends Readable {
+  /**
+   * The Blob or File object being read.
+   */
+  readonly blob: Blob | File;
+
+  /**
+   * Creates a new BlobReadStream instance.
+   * @param blob - Blob or File object to read from
+   * @param options - Stream options
+   */
+  constructor(blob: Blob | File, options?: BlobReadStreamOptions);
+}
+
+/**
+ * Main module function to look up or create a Socket instance.
+ * This function also has properties attached to it (Socket, IOStream, etc.)
+ */
+declare function lookup(sio: SocketIOSocketLike, options?: SocketOptions): Socket;
+
+declare namespace lookup {
+  /**
+   * Socket constructor class
+   */
+  const Socket: typeof Socket;
+  
+  /**
+   * IOStream constructor class
+   */
+  const IOStream: typeof IOStream;
+  
+  /**
+   * BlobReadStream constructor class
+   */
+  const BlobReadStream: typeof BlobReadStream;
+  
+  /**
+   * Forces base 64 encoding when emitting. Must be set to true for Socket.IO v0.9 or lower.
+   * @default false
+   */
+  let forceBase64: boolean;
+  
+  /**
+   * Exposes Node Buffer for browser compatibility.
+   */
+  const Buffer: typeof global.Buffer;
+  
+  /**
+   * Creates a new duplex stream.
+   * @param options - Stream options
+   * @returns New IOStream instance
+   */
+  function createStream(options?: IOStreamOptions): IOStream;
+  
+  /**
+   * Creates a new readable stream for Blob/File on browser.
+   * @param blob - Blob or File object to read from
+   * @param options - Stream options
+   * @returns New BlobReadStream instance
+   */
+  function createBlobReadStream(
+    blob: Blob | File,
+    options?: BlobReadStreamOptions
+  ): BlobReadStream;
+}
+
+export = lookup;

package/index.js

@@ -0,0 +1,3 @@
+
+module.exports = require('./lib');
+

package/lib/blob-read-stream.js

@@ -0,0 +1,67 @@
+var util = require('util');
+var Readable = require('readable-stream').Readable;
+var bind = require('component-bind');
+
+
+module.exports = BlobReadStream;
+
+util.inherits(BlobReadStream, Readable);
+
+/**
+ * Readable stream for Blob and File on browser.
+ *
+ * @param {Object} options
+ * @api private
+ */
+function BlobReadStream(blob, options) {
+  if (!(this instanceof BlobReadStream)) {
+    return new BlobReadStream(blob, options);
+  }
+
+  Readable.call(this, options);
+
+  options = options || {};
+  this.blob = blob;
+  this.slice = blob.slice || blob.webkitSlice || blob.mozSlice;
+  this.start = 0;
+  this.sync = options.synchronous || false;
+
+  var fileReader;
+
+  if (options.synchronous) {
+    fileReader = this.fileReader = new FileReaderSync();
+  } else {
+    fileReader = this.fileReader = new FileReader();
+  }
+
+  fileReader.onload = bind(this, '_onload');
+  fileReader.onerror = bind(this, '_onerror');
+}
+
+BlobReadStream.prototype._read = function(size) {
+  var start = this.start;
+  var end = this.start = this.start + size;
+  var chunk = this.slice.call(this.blob, start, end);
+
+  if (chunk.size) {
+    if (this.sync) {
+      var bufferChunk = new Buffer(new Uint8Array(this.fileReader.readAsArrayBuffer(chunk)));
+      this.push(bufferChunk);
+    } else {
+      this.fileReader.readAsArrayBuffer(chunk);
+    }
+  } else {
+    this.push(null);
+  }
+}
+
+BlobReadStream.prototype._onload = function(e) {
+  var chunk = new Buffer(new Uint8Array(e.target.result));
+  this.push(chunk);
+};
+
+BlobReadStream.prototype._onerror = function(e) {
+  var err = e.target.error;
+  this.emit('error', err);
+};
+

package/lib/index.js

@@ -0,0 +1,77 @@
+var Socket = require('./socket');
+var IOStream = require('./iostream');
+var BlobReadStream = require('./blob-read-stream');
+
+
+exports = module.exports = lookup;
+
+/**
+ * Expose Node Buffer for browser.
+ *
+ * @api public
+ */
+exports.Buffer = Buffer;
+
+/**
+ * Expose Socket constructor.
+ *
+ * @api public
+ */
+exports.Socket = Socket;
+
+/**
+ * Expose IOStream constructor.
+ *
+ * @api public
+ */
+exports.IOStream = IOStream;
+
+/**
+ * Forces base 64 encoding when emitting. Must be set to true for Socket.IO v0.9 or lower.
+ *
+ * @api public
+ */
+exports.forceBase64 = false;
+
+/**
+ * Look up an existing Socket.
+ *
+ * @param {socket.io#Socket} socket.io
+ * @param {Object} options
+ * @return {Socket} Socket instance
+ * @api public
+ */
+function lookup(sio, options) {
+  options = options || {};
+  if (null == options.forceBase64) {
+    options.forceBase64 = exports.forceBase64;
+  }
+
+  if (!sio._streamSocket) {
+    sio._streamSocket = new Socket(sio, options);
+  }
+  return sio._streamSocket;
+}
+
+/**
+ * Creates a new duplex stream.
+ *
+ * @param {Object} options
+ * @return {IOStream} duplex stream
+ * @api public
+ */
+exports.createStream = function(options) {
+  return new IOStream(options);
+};
+
+/**
+ * Creates a new readable stream for Blob/File on browser.
+ *
+ * @param {Blob} blob
+ * @param {Object} options
+ * @return {BlobReadStream} stream
+ * @api public
+ */
+exports.createBlobReadStream = function(blob, options) {
+  return new BlobReadStream(blob, options);
+};

package/lib/iostream.js

@@ -0,0 +1,265 @@
+var util = require('util');
+var Duplex = require('readable-stream').Duplex;
+var bind = require('component-bind');
+var uuid = require('./uuid');
+var debug = require('debug')('socket.io-stream:iostream');
+
+
+module.exports = IOStream;
+
+util.inherits(IOStream, Duplex);
+
+/**
+ * Duplex
+ *
+ * @param {Object} options
+ * @api private
+ */
+function IOStream(options) {
+  if (!(this instanceof IOStream)) {
+    return new IOStream(options);
+  }
+
+  IOStream.super_.call(this, options);
+
+  this.options = options;
+  this.id = uuid();
+  this.socket = null;
+
+  // Buffers
+  this.pushBuffer = [];
+  this.writeBuffer = [];
+
+  // Op states
+  this._readable = false;
+  this._writable = false;
+  this.destroyed = false;
+
+  // default to *not* allowing half open sockets
+  this.allowHalfOpen = options && options.allowHalfOpen || false;
+
+  this.on('finish', this._onfinish);
+  this.on('end', this._onend);
+  this.on('error', this._onerror);
+}
+
+/**
+ * Ensures that no more I/O activity happens on this stream.
+ * Not necessary in the usual case.
+ *
+ * @api public
+ */
+IOStream.prototype.destroy = function() {
+  debug('destroy');
+
+  if (this.destroyed) {
+    debug('already destroyed');
+    return;
+  }
+
+  this.readable = this.writable = false;
+
+  if (this.socket) {
+    debug('clean up');
+    this.socket.cleanup(this.id);
+    this.socket = null;
+  }
+
+  this.destroyed = true;
+};
+
+/**
+ * Local read
+ *
+ * @api private
+ */
+IOStream.prototype._read = function(size) {
+  var push;
+
+  // We can not read from the socket if it's destroyed obviously ...
+  if (this.destroyed) return;
+
+  if (this.pushBuffer.length) {
+    // flush buffer and end if it exists.
+    while (push = this.pushBuffer.shift()) {
+      if (!push()) break;
+    }
+    return;
+  }
+
+  this._readable = true;
+
+  // Go get data from remote stream
+  // Calls
+  // ._onread remotely
+  // then
+  // ._onwrite locally
+  this.socket._read(this.id, size);
+};
+
+
+/**
+ * Read from remote stream
+ *
+ * @api private
+ */
+IOStream.prototype._onread = function(size) {
+  var write = this.writeBuffer.shift();
+  if (write) return write();
+
+  this._writable = true;
+};
+
+/**
+ * Write local data to remote stream
+ * Calls
+ * remtote ._onwrite
+ *
+ * @api private
+ */
+IOStream.prototype._write = function(chunk, encoding, callback) {
+  var self = this;
+
+  function write() {
+    // We can not write to the socket if it's destroyed obviously ...
+    if (self.destroyed) return;
+
+    self._writable = false;
+    self.socket._write(self.id, chunk, encoding, callback);
+  }
+
+  if (this._writable) {
+    write();
+  } else {
+    this.writeBuffer.push(write);
+  }
+};
+
+/**
+ * Write the data fetched remotely
+ * so that we can now read locally
+ *
+ * @api private
+ */
+IOStream.prototype._onwrite = function(chunk, encoding, callback) {
+  var self = this;
+
+  function push() {
+    self._readable = false;
+    var ret = self.push(chunk || '', encoding);
+    callback();
+    return ret;
+  }
+
+  if (this._readable) {
+    push();
+  } else {
+    this.pushBuffer.push(push);
+  }
+};
+
+/**
+ * When ending send 'end' event to remote stream
+ *
+ * @api private
+ */
+IOStream.prototype._end = function() {
+  if (this.pushBuffer.length) {
+    // end after flushing buffer.
+    this.pushBuffer.push(bind(this, '_done'));
+  } else {
+    this._done();
+  }
+};
+
+/**
+ * Remote stream just ended
+ *
+ * @api private
+ */
+IOStream.prototype._done = function() {
+  this._readable = false;
+
+  // signal the end of the data.
+  return this.push(null);
+};
+
+/**
+ * the user has called .end(), and all the bytes have been
+ * sent out to the other side.
+ * If allowHalfOpen is false, or if the readable side has
+ * ended already, then destroy.
+ * If allowHalfOpen is true, then we need to set writable false,
+ * so that only the writable side will be cleaned up.
+ *
+ * @api private
+ */
+IOStream.prototype._onfinish = function() {
+  debug('_onfinish');
+  // Local socket just finished
+  // send 'end' event to remote
+  if (this.socket) {
+    this.socket._end(this.id);
+  }
+
+  this.writable = false;
+  this._writableState.ended = true;
+
+  if (!this.readable || this._readableState.ended) {
+    debug('_onfinish: ended, destroy %s', this._readableState);
+    return this.destroy();
+  }
+
+  debug('_onfinish: not ended');
+
+  if (!this.allowHalfOpen) {
+    this.push(null);
+
+    // just in case we're waiting for an EOF.
+    if (this.readable && !this._readableState.endEmitted) {
+      this.read(0);
+    }
+  }
+};
+
+/**
+ * the EOF has been received, and no more bytes are coming.
+ * if the writable side has ended already, then clean everything
+ * up.
+ *
+ * @api private
+ */
+IOStream.prototype._onend = function() {
+  debug('_onend');
+  this.readable = false;
+  this._readableState.ended = true;
+
+  if (!this.writable || this._writableState.finished) {
+    debug('_onend: %s', this._writableState);
+    return this.destroy();
+  }
+
+  debug('_onend: not finished');
+
+  if (!this.allowHalfOpen) {
+    this.end();
+  }
+};
+
+/**
+ * When error in local stream
+ * notyify remote
+ * if err.remote = true
+ * then error happened on remote stream
+ *
+ * @api private
+ */
+IOStream.prototype._onerror = function(err) {
+  // check if the error came from remote stream.
+  if (!err.remote && this.socket) {
+    // notify the error to the corresponding remote stream.
+    this.socket._error(this.id, err);
+  }
+
+  this.destroy();
+};

package/lib/parser.js

@@ -0,0 +1,105 @@
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var IOStream = require('./iostream');
+var slice = Array.prototype.slice;
+
+exports.Encoder = Encoder;
+exports.Decoder = Decoder;
+
+util.inherits(Encoder, EventEmitter);
+
+function Encoder() {
+  EventEmitter.call(this);
+}
+
+/**
+ * Encode streams to placeholder objects.
+ *
+ * @api public
+ */
+Encoder.prototype.encode = function(v) {
+  if (v instanceof IOStream) {
+    return this.encodeStream(v);
+  } else if (util.isArray(v)) {
+    return this.encodeArray(v);
+  } else if (v && 'object' == typeof v) {
+    return this.encodeObject(v);
+  }
+  return v;
+}
+
+Encoder.prototype.encodeStream = function(stream) {
+  this.emit('stream', stream);
+
+  // represent a stream in an object.
+  var v = { $stream: stream.id };
+  if (stream.options) {
+    v.options = stream.options;
+  }
+  return v;
+}
+
+Encoder.prototype.encodeArray = function(arr) {
+  var v = [];
+  for (var i = 0, len = arr.length; i < len; i++) {
+    v.push(this.encode(arr[i]));
+  }
+  return v;
+}
+
+Encoder.prototype.encodeObject = function(obj) {
+  var v = {};
+  for (var k in obj) {
+    if (obj.hasOwnProperty(k)) {
+      v[k] = this.encode(obj[k]);
+    }
+  }
+  return v;
+}
+
+util.inherits(Decoder, EventEmitter);
+
+function Decoder() {
+  EventEmitter.call(this);
+}
+
+/**
+ * Decode placeholder objects to streams.
+ *
+ * @api public
+ */
+Decoder.prototype.decode = function(v) {
+  if (v && v.$stream) {
+    return this.decodeStream(v);
+  } else if (util.isArray(v)) {
+    return this.decodeArray(v);
+  } else if (v && 'object' == typeof v) {
+    return this.decodeObject(v);
+  }
+  return v;
+}
+
+Decoder.prototype.decodeStream = function(obj) {
+  var stream = new IOStream(obj.options);
+  stream.id = obj.$stream;
+  this.emit('stream', stream);
+  return stream;
+}
+
+Decoder.prototype.decodeArray = function(arr) {
+  var v = [];
+  for (var i = 0, len = arr.length; i < len; i++) {
+    v.push(this.decode(arr[i]));
+  }
+  return v;
+}
+
+Decoder.prototype.decodeObject = function(obj) {
+  var v = {};
+  for (var k in obj) {
+    if (obj.hasOwnProperty(k)) {
+      v[k] = this.decode(obj[k]);
+    }
+  }
+  return v;
+}

package/lib/socket.js

@@ -0,0 +1,287 @@
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var bind = require('component-bind');
+var IOStream = require('./iostream');
+var parser = require('./parser');
+var debug = require('debug')('socket.io-stream:socket');
+var emit = EventEmitter.prototype.emit;
+var on = EventEmitter.prototype.on;
+var slice = Array.prototype.slice;
+
+
+exports = module.exports = Socket;
+
+/**
+ * Base event name for messaging.
+ *
+ * @api public
+ */
+exports.event = '$stream';
+
+exports.events = [
+  'error',
+  'newListener',
+  'removeListener'
+];
+
+util.inherits(Socket, EventEmitter);
+
+/**
+ * Bidirectional stream socket which wraps Socket.IO.
+ *
+ * @param {socket.io#Socket} socket.io
+ * @api public
+ */
+function Socket(sio, options) {
+  if (!(this instanceof Socket)) {
+    return new Socket(sio, options);
+  }
+
+  EventEmitter.call(this);
+
+  options = options || {};
+
+  this.sio = sio;
+  this.forceBase64 = !!options.forceBase64;
+  this.streams = {};
+  this.encoder = new parser.Encoder();
+  this.decoder = new parser.Decoder();
+
+  var eventName = exports.event;
+  sio.on(eventName, bind(this, emit));
+  sio.on(eventName + '-read', bind(this, '_onread'));
+  sio.on(eventName + '-write', bind(this, '_onwrite'));
+  sio.on(eventName + '-end', bind(this, '_onend'));
+  sio.on(eventName + '-error', bind(this, '_onerror'));
+  sio.on('error', bind(this, emit, 'error'));
+  sio.on('disconnect', bind(this, '_ondisconnect'));
+
+  this.encoder.on('stream', bind(this, '_onencode'));
+  this.decoder.on('stream', bind(this, '_ondecode'));
+}
+
+/**
+ * Original emit function.
+ *
+ * @api private
+ */
+Socket.prototype.$emit = emit;
+
+/**
+ * Emits streams to this corresponding server/client.
+ *
+ * @return {Socket} self
+ * @api public
+ */
+Socket.prototype.emit = function(type) {
+  if (~exports.events.indexOf(type)) {
+    return emit.apply(this, arguments);
+  }
+  this._stream.apply(this, arguments);
+  return this;
+};
+
+Socket.prototype.on = function(type, listener) {
+  if (~exports.events.indexOf(type)) {
+    return on.apply(this, arguments);
+  }
+
+  this._onstream(type, listener);
+  return this;
+};
+
+/**
+ * Sends a new stream request.
+ *
+ * @param {String} event type
+ * @api private
+ */
+Socket.prototype._stream = function(type) {
+  debug('sending new streams');
+
+  var self = this;
+  var args = slice.call(arguments, 1);
+  var ack = args[args.length - 1];
+  if ('function' == typeof ack) {
+    args[args.length - 1] = function() {
+      var args = slice.call(arguments);
+      args = self.decoder.decode(args);
+      ack.apply(this, args);
+    };
+  }
+
+  args = this.encoder.encode(args);
+  var sio = this.sio;
+  sio.emit.apply(sio, [exports.event, type].concat(args));
+};
+
+/**
+ * Notifies the read event.
+ *
+ * @api private
+ */
+Socket.prototype._read = function(id, size) {
+  this.sio.emit(exports.event + '-read', id, size);
+};
+
+/**
+ * Requests to write a chunk.
+ *
+ * @api private
+ */
+Socket.prototype._write = function(id, chunk, encoding, callback) {
+  if (Buffer.isBuffer(chunk)) {
+    if (this.forceBase64) {
+      encoding = 'base64';
+      chunk = chunk.toString(encoding);
+    } else if (!global.Buffer) {
+      // socket.io can't handle Buffer when using browserify.
+      if (chunk.toArrayBuffer) {
+        chunk = chunk.toArrayBuffer();
+      } else {
+        chunk = chunk.buffer;
+      }
+    }
+  }
+  this.sio.emit(exports.event + '-write', id, chunk, encoding, callback);
+};
+
+Socket.prototype._end = function(id) {
+  this.sio.emit(exports.event + '-end', id);
+};
+
+Socket.prototype._error = function(id, err) {
+  this.sio.emit(exports.event + '-error', id, err.message || err);
+};
+
+/**
+ * Handles a new stream request.
+ *
+ * @param {String} event type
+ * @param {Function} listener
+ *
+ * @api private
+ */
+Socket.prototype._onstream = function(type, listener) {
+  if ('function' != typeof listener) {
+    throw TypeError('listener must be a function');
+  }
+
+  function onstream() {
+    debug('new streams');
+    var self = this;
+    var args = slice.call(arguments);
+    var ack = args[args.length - 1];
+    if ('function' == typeof ack) {
+      args[args.length - 1] = function() {
+        var args = slice.call(arguments);
+        args = self.encoder.encode(args);
+        ack.apply(this, args);
+      };
+    }
+
+    args = this.decoder.decode(args);
+    listener.apply(this, args);
+  }
+
+  // for removeListener
+  onstream.listener = listener;
+
+  on.call(this, type, onstream);
+};
+
+Socket.prototype._onread = function(id, size) {
+  debug('read: "%s"', id);
+
+  var stream = this.streams[id];
+  if (stream) {
+    stream._onread(size);
+  } else {
+    debug('ignore invalid stream id');
+  }
+};
+
+Socket.prototype._onwrite = function(id, chunk, encoding, callback) {
+  debug('write: "%s"', id);
+
+  var stream = this.streams[id];
+  if (!stream) {
+    callback('invalid stream id: ' + id);
+    return;
+  }
+
+  if (global.ArrayBuffer && chunk instanceof ArrayBuffer) {
+    // make sure that chunk is a buffer for stream
+    chunk = new Buffer(new Uint8Array(chunk));
+  }
+  stream._onwrite(chunk, encoding, callback);
+};
+
+Socket.prototype._onend = function(id) {
+  debug('end: "%s"', id);
+
+  var stream = this.streams[id];
+  if (!stream) {
+    debug('ignore non-existent stream id: "%s"', id);
+    return;
+  }
+
+  stream._end();
+};
+
+Socket.prototype._onerror = function(id, message) {
+  debug('error: "%s", "%s"', id, message);
+
+  var stream = this.streams[id];
+  if (!stream) {
+    debug('invalid stream id: "%s"', id);
+    return;
+  }
+
+  var err = new Error(message);
+  err.remote = true;
+  stream.emit('error', err);
+};
+
+Socket.prototype._ondisconnect = function() {
+  var stream;
+  for (var id in this.streams) {
+    stream = this.streams[id];
+    stream.destroy();
+
+    // Close streams when the underlaying
+    // socket.io connection is closed (regardless why)
+    stream.emit('close');
+    stream.emit('error', new Error('Connection aborted'));
+  }
+};
+
+Socket.prototype._onencode = function(stream) {
+  if (stream.socket || stream.destroyed) {
+    throw new Error('stream has already been sent.');
+  }
+
+  var id = stream.id;
+  if (this.streams[id]) {
+    throw new Error('Encoded stream already exists: ' + id);
+  }
+
+  this.streams[id] = stream;
+  stream.socket = this;
+};
+
+Socket.prototype._ondecode = function(stream) {
+  var id = stream.id;
+  if (this.streams[id]) {
+    this._error(id, new Error('Decoded stream already exists: ' + id));
+    return;
+  }
+
+  this.streams[id] = stream;
+  stream.socket = this;
+};
+
+Socket.prototype.cleanup = function(id) {
+  delete this.streams[id];
+};
+

package/lib/uuid.js

@@ -0,0 +1,25 @@
+// UUID function from https://gist.github.com/jed/982883
+// More lightweight than node-uuid
+function b(
+  a                  // placeholder
+){
+  return a           // if the placeholder was passed, return
+    ? (              // a random number from 0 to 15
+      a ^            // unless b is 8,
+      Math.random()  // in which case
+      * 16           // a random number from
+      >> a/4         // 8 to 11
+      ).toString(16) // in hexadecimal
+    : (              // or otherwise a concatenated string:
+      [1e7] +        // 10000000 +
+      -1e3 +         // -1000 +
+      -4e3 +         // -4000 +
+      -8e3 +         // -80000000 +
+      -1e11          // -100000000000,
+      ).replace(     // replacing
+        /[018]/g,    // zeroes, ones, and eights with
+        b            // random hex digits
+      )
+}
+
+module.exports = b;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@sawa-siemens/socket.io-stream",
+  "version": "0.10.0",
+  "description": "stream for socket.io",
+  "author": "Naoyuki Kanezawa <naoyuki.kanezawa@gmail.com>",
+  "contributors": [
+    {
+      "name": "Naoyuki Kanezawa",
+      "email": "naoyuki.kanezawa@gmail.com"
+    },
+    {
+      "name": "Aaron O'Mullan",
+      "email": "aaron.omullan@friendco.de"
+    },
+    {
+      "name": "Sawa",
+      "email": "sawa.yeung.ext@siemens.com"
+    }
+  ],
+  "keywords": [
+    "stream",
+    "socket.io",
+    "binary",
+    "file",
+    "upload",
+    "download"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "browser": "socket.io-stream.js",
+  "exports": {
+    ".": {
+      "node": "./index.js",
+      "browser": "./socket.io-stream.js",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sawa-siemens/socket.io-stream.git"
+  },
+  "scripts": {
+    "prepublish": "make build",
+    "test": "make test"
+  },
+  "dependencies": {
+    "component-bind": "~1.0.0",
+    "debug": "^4.3.4"
+  },
+  "devDependencies": {
+    "browserify": "^17.0.0",
+    "expect.js": "~0.3.1",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3"
+  }
+}

package/socket.io-stream.js

@@ -0,0 +1,4 @@
+(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.ss = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+
+},{}]},{},[1])(1)
+});