more API reference stuff

docs/api.json

@@ -0,0 +1,80 @@
+[
+  {
+    "name": "Peer",
+    "type": "constructor",
+    "snippet": "var peer = new Peer([id], [options]);",
+    "description": "A Peer can connect to other peers and listen for connections.",
+    "children": [
+      {
+        "name": "id",
+        "optional": true,
+        "type": "string",
+        "description": "Other peers can connect to this peer using the provided ID. If no ID is given, one will be generated by the brokering server.<div class='tip'>It is not recommended that you use this ID to identify peers, as it's meant to be used for brokering connections only. You're recommended to set the metadata option to send other identifying information.</div>"
+      },
+      {
+        "name": "options",
+        "optional": true,
+        "type": "object",
+        "children": [
+          {
+            "name": "key",
+            "type": "string",
+            "description": "API key for the cloud PeerServer. This is not used for servers other than <code>0.peerjs.com</code>."
+          },
+          {
+            "name": "host",
+            "type": "string",
+            "description": "Server host. Defaults to <code>0.peerjs.com</code>. Also accepts <code>'/'</code> to signify relative hostname."
+          },
+          {
+            "name": "port",
+            "type": "number",
+            "description": "Server port. Defaults to <code>80</code>."
+          },
+          {
+            "name": "config",
+            "type": "object",
+            "description": "Configuration hash passed to RTCPeerConnection. This hash contains the ICE servers. Defaults to <code>{ 'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }] }</code>"
+          },
+          {
+            "name": "debug",
+            "type": "number",
+            "description": "Prints log messages depending on the debug level passed in. Defaults to <code>0</code>.",
+            "children": [
+              {
+                "name": 0,
+                "description": "Prints no logs."
+              },
+              {
+                "name": 1,
+                "description": "Prints only errors."
+              },
+              {
+                "name": 2,
+                "description": "Prints errors and warnings."
+              },
+              {
+                "name": 3,
+                "description": "Prints all logs."
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  },
+
+  {
+    "name": "peer.connect",
+    "type": "method",
+    "snippet": "var connection = peer.connect(id, [options]);",
+    "description": "Does something",
+    "children": [
+      {
+        "name": "id",
+        "type": "string",
+        "description": "Something else"
+      }
+    ]
+  }
+]

docs/api.md

@@ -1,210 +1,4 @@
 # PeerJS API Reference
 
-**Due to browsers' incomplete support of the WebRTC DataChannel specification, many features of PeerJS have caveats.
-[View the status page for full details](http://peerjs.com/status).**
-
-## Class: peerjs.Peer
-
-This class is a Peer, which can connect to other peers and listen for connections. It is an `EventEmitter`.
-
-### new Peer([id], [options])
-
-* `id` String. The id by which this peer will be identified when other peers try to connect to it. If no id is given, one will be generated by the server. **Note that this ID is mainly used for brokering and that it is not recommended that you use it to identify peers. Also note that you can set a `metadata` option to send other identifying information.**
-* `options` Object
-  * `key` String. API key for cloud PeerServer. Is not used for servers other than `cloud.peerjs.com`
-  * `host` String. Server host. Default `cloud.peerjs.com`. Also accepts `'/'` for relative hostname.
-  * `port` Number. Server port. Default `80`
-  * `config` Object. Configuration hash passed to `RTCPeerConnection`. This hash contains the ICE servers. Default `{ 'iceServers': [{ 'url': 'stun:stun.l.google.com:19302' }] }`
-  * `debug` Boolean. Prints verbose log messages. Default `false` 
-
-Construct a new Peer object.
-
-The Peer object is used to connect to other Peer clients and also to receive connections from other clients.
-
-The first argument is the id that other peers will use to connect to this peer, thus it must be unique for the given `key` (if you're using PeerServer cloud) or server.
-
-In the options, either a PeerServer Cloud `key` must be provided or `host` and `port` for your own PeerServer. **Note that the server is only for brokering connections and does not proxy data between peers.**
-
-The `config` object is passed straight into instances of `RTCPeerConnection`. For compatibility with symmetric NATs, you can provide your own TURN server. By default the STUN server provided by Google is used.
-
-### Peer.browser (deprecated after 0.3.0)
-
-The type of browser the client is on. Currently WebRTC DataChannels are not
-interoperable so different browser types should not be connected.
-
-### peer.id
-
-The given id of this peer.
-
-If no id was specified in the constructor, this value will be `undefined` util the `open` event fires.
-
-### peer.connections
-
-A hash of all current connections with the current peer. Keys are ids and values are hashes of label => `DataConnection` pairs.
-
-**You are recommended to keep track of connections yourself rather than to manipulate this hash.**
-
-### peer.connect(id, [options])
-
-Connects to the remote peer specified by `id`.
-
-This function can be called multiple times for multiplexed connections between
-two peers. In Firefox however this functionality is only available before the
-first connection is established.
-
-Returns a `DataConnection` object.
-
-* `id` String. The id of the remote peer to connect to.
-* `options` Object.
-  * `label` Optional label for the underlying DataChannel, to differentiate between DataConnections between the same two peers. If left unspecified, a label will be assigned at random.
-  * `metadata` Optional metadata to pass to the remote peer. Can be any serializable type.
-  * `serialization` String, which can be `binary`, `binary-utf8`, `json`, or `none`. This will be the serialization format of all data sent over the P2P DataConnection. Defaults to `binary`.
-  * `reliable` Boolean, which if `true` activates experimental reliable transfer in Chrome (while waiting for actual reliable transfer to be implemented in Chrome). Defaults to `false` until Chrome implements reliable/large data transfer. Defaults to true in Firefox.
-
-Before writing to / data will be emitted from the `DataConnection` object that is returned, the `open` event must fire. Also the `error` event should be checked in case a connection cannot be made.
-
-### peer.destroy()
-
-Close the connection to the server and terminate all connections.
-
-**Warning: This cannot be undone; the respective peer object will no longer be able to create or receive any connections and its ID will be forfeited on the (cloud) server.**
-
-### peer.disconnect()
-
-Close the connection to the server, leaving all existing DataConnections intact.
-
-**Warning: This cannot be undone; the respective peer object will no longer be able to create or receive any connections and its ID will be forfeited on the (cloud) server.**
-
-### peer.disconnected
-
-Is false if there is an active connection to the PeerServer.
-
-### peer.destroyed
-
-Is true if this peer is destroyed and can no longer be used.
-
-### Event: 'connection'
-
-`function (connection, meta) { }`
-
-When a new connection is established from another peer to this peer, the `DataConnection` object is emitted with this event. The `meta` argument contains whatever metadata values passed into `peer.connection(...)` by the remote peer.
-
-**Note:** the `open` event must fire on the `DataConnection` before it is ready to read/write.
-
-### Event: 'open'
-
-`function(id) { }`
-
-Fired when the PeerServer connection is succesfully, fully, open.
-This event does not need to fire before creating or receiving connections.
-**You should not wait for open before connecting to other peers or expecting to receive connections if connection speed is important.**
-
-`id` is the id of this `Peer` object, either provided in the constructor, or generated automatically by the PeerServer.
-
-### Event: 'error'
-
-`function (error) { }`
-
-Emitted when an unexpected event occurs. Errors on the Peer are **always
-fatal**. Errors from the underlying socket and PeerConnections are forwarded here.
-
-The `error` object also has a `type` parameter that may be helpful in responding to client errors properly:
-* `browser-incompatible`: The client's browser does not support some or all WebRTC features that you are trying to use.
-* `invalid-id`: The ID passed into the Peer constructor contains illegal characters.
-* `invalid-key`: The API key passed into the Peer constructor contains illegal characters or is not in the system (cloud server only).
-* `unavailable-id`: The ID passed into the Peer constructor is already taken.
-* `firefoxism`: The operation you're trying to perform is not supported in firefox.
-* `ssl-unavailable`: PeerJS is being used securely, but the cloud server does not support SSL. Use a custom PeerServer.
-* Errors types that shouldn't regularly appear:
-  * `server-error`: Unable to reach the server.
-  * `socket-error`: An error from the underlying socket.
-  * `socket-closed`: The underlying socket closed unexpectedly.
-* (The Peer object is destroyed after one of the errors above are emitted.)
-* `server-disconnected`: A Peer that has been disconnected is being used to try to connect.
-
-### Event: 'close'
-
-`function () { }`
-
-Emitted when the Peer object has closed its connection with PeerServer so no more remote peer connections can be made or received.
-
-To be extra certain that Peer objects clean up cleanly (and because it takes the WS server and DataChannel some time to realize that a Peer has disconnected), it is best to call `destroy()` on a Peer when it is no longer needed.
-
-## Class: peerjs.DataConnection
-
-This class is the interface two communicate between two peers. It is an `EventEmitter`.
-
-There is no constructor. A `DataConnection` object must be obtained in the callback of `peer.connect(...)` when initiating a peer-to-peer connection or emitted in the `peer.on('connection', ...)` event when receiving a connection.
-
-### EXPERIMENTAL reliable and large file transfer:
-
-(CHROME ONLY. Firefox has reliable transport built in and reliable transfer is the default option.) Simply pass in `reliable: true` when calling `.connect(...)`. This module is experimental, temporary, and exists here: https://github.com/michellebu/reliable
-
-*Caveat:* With reliable enabled in Chrome, you can no longer customize the serialization format used for data transfer.
-
-### connection.peer
-
-The id of the remote peer this connection is connected to.
-
-### connection.open
-
-Whether the connection is open (ready for read and write).
-
-### connection.metadata
-
-The metadata passed in when the connection was created with `peer.connect(...)`.
-
-### connection.label
-
-The optional label passed in or assigned by PeerJS when the connection was created with `peer.connect(...)`.
-
-### connection.serialization
-
-The serialization format of the connection. Can be `binary`, `binary-utf8`, `json`, or `none`
-for no serialization. Default serialization format is `binary`.
-
-**Note:** `binary-utf8` will take a performance hit because of the way utf8 strings are packed into binary.
-
-### connection.send(data)
-
-Accepts data of any JSON type or binary type.
-
-To configure which serialization format to use, specify `binary`, `binary-utf8`, `json`, or `none` as the `serialization` property of the `options` object in `peer.connect(...)`.
-
-Data is serialized using BinaryPack (`binary`) by default and then sent to the remote peer.
-
-### connection.close()
-
-Gracefully closes the connection.
-
-### Event: 'data'
-
-`function (data) { }`
-
-Emitted when data is received from the remote peer. 
-
-The `data` parameter contains values exactly as put into the `connection.send(...)`. Binary types will have been deserialized to `ArrayBuffer`.
-
-### Event: 'open'
-
-`function () { }`
-
-Emitted when the connection is established and ready for writing. `data` from the remote peer will also start to be emitted.
-
-### Event: 'error'
-
-`function (error) { }`
-
-If the connection emits an error, this event is emitted (errors from the underlying `DataChannel` are forwarded here).
-
-`error` is an `Error` object.
-
-### Event: 'close'
-
-`function () { }`
-
-Is emitted when the connection is closed.
-
-The `close` event is also emitted when the remote peer closes the connection.
-
-
+We've moved! <a href="http://peerjs.com/docs#api">Check out our new API
+reference.</a>

docs/build.js

@@ -0,0 +1,8 @@
+var fs = require('fs');
+var handlebars = require('handlebars');
+var reference = require('reference');
+
+var file = fs.readFileSync('./api.json');
+
+var template = handlebars.compile(fs.readFileSync('./template.html', {encoding: 'utf8'}));
+fs.writeFile('./index.html', template({html: reference(file)}));

docs/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "docs",
+  "version": "0.0.0",
+  "description": "**Due to browsers' incomplete support of the WebRTC DataChannel specification, many features of PeerJS have caveats.\r [View the status page for full details](http://peerjs.com/status).**",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": "",
+  "author": "",
+  "license": "BSD",
+  "readmeFilename": "readme.md",
+  "dependencies": {
+    "reference": "0.0.0",
+    "handlebars": "~1.0.12"
+  }
+}

docs/style.css

@@ -26,11 +26,15 @@ body, html {
   background-color: #f5f5f5;
 }
 
-.toplevel div {
-  padding: 0 0 5px 10px;
+.child {
+  padding: 8px 0 8px 15px;
 }
 
-.options, .arguments, .methods {
+.toplevel .children > .child {
+  padding-right: 15px;
+}
+
+.children {
   border-left: 1px dashed #ccc;
 }
 
@@ -38,8 +42,12 @@ body, html {
   margin: 0 0 5px 0;
 }
 
+.child:hover {
+  background-color: #fff;
+}
+
 /** Label stylings */
-.api .label {
+.api .type {
   display: inline-block;
   background-color: #454545;
   border-radius: 2px;
@@ -47,28 +55,26 @@ body, html {
   color: #fff;
   line-height: 11px;
   padding: 1px 2px;
+  margin-left: 5px;
   font-size: 10px;
   font-weight: 600;
   text-transform: uppercase;
   text-shadow: 0px -1px 0px rgba(0,0,0,0.2);
-}
-
-span.label.type {
   background-color: #757E2B;
 }
 
-span.label.required {
-  background-color: #8E2603;
+.toplevel > .name {
+  font-size: 20px;
 }
 
-.options .label {
-  background-color: #E2A62E;
-}
 /** /Label stylings */
 
 .api .snippet {
   font: 12px Courier;
   display: inline-block;
+  background-color: #fff;
+  padding: 5px 10px;
+  margin-left: 5px;
 }
 
 .api .name {
@@ -76,3 +82,14 @@ span.label.required {
   display: inline-block;
   margin-bottom: 5px;
 }
+
+.api .code {
+  font-family: Courier;
+}
+
+.tip {
+  background-color: #333;
+  font-size: 12px;
+  padding: 10px;
+  color: #fff;
+}

docs/template.html

@@ -0,0 +1,102 @@
+<head>
+  <link href="./style.css" rel="stylesheet" type="text/css">
+</head>
+
+<body>
+  <section class="api">
+
+    <h2>API Reference</h2>
+
+    {{{html}}}
+
+  </section>
+
+  <section class="start">
+    <h1>PeerJS Documentation [SAMPLE]</h1>
+    <h2>Get started with PeerJS</h2>
+
+      <div class="warning">Due to browsers' incomplete support of the WebRTC DataChannel specification, many features of PeerJS have caveats.<br><a href="/status">View the status page for full details</a>.</div>
+      <p>PeerJS requires two components: the PeerJS client library and the PeerServer.</p>
+
+    <h2>PeerServer</h2>
+
+      <p>The PeerServer brokers connections between PeerJS clients. Once two clients have established a connection with each other with the PeerServer's help, data is will flow between the clients directly.</p>
+      <p>Choose one of the following options:</p>
+      <p><a href="/peerserver">Sign up for free cloud-hosted PeerServer service</a></p>
+      <p>Alternatively, <a href="http://github.com/peers/peerjs-server">PeerServer is
+      available on GitHub</a> and on <a href="https://npmjs.org/package/peer">npm</a>:</a>
+      <pre><code>npm install peer</code></pre>
+      <p>Setting up the server on your own is just a few lines of code:</a>
+      <pre><code>var PeerServer = require('peer').PeerServer;
+      var server = new PeerServer({ port: 9000 });</code></pre>
+
+    <h2>PeerJS Client</h2>
+
+      <p>The client is where all the action is at.<p>
+      <h3>1. Include the PeerJS client in your frontend Javascript code:</h3>
+      <pre><code>&lt;script src="http://cdn.peerjs.com/0/peer.min.js"&gt;&lt;/script&gt;
+      </code></pre>
+      <h3>2. Create the Peer object.</h3>
+      <p>
+      You'll need to provide an ID. When other peers try to connect to you, they'll have to know this ID.</p>
+      <p>
+      Also you'll need to provide either the API key for your PeerServer cloud account or your own PeerServer:
+      </p>
+      <pre><code>var peer = new Peer('some-id', {key: 'myapikey'});
+      </code></pre>
+      <p>Or if you're running your own PeerServer</p>
+      <pre><code>var peer = new Peer('some-id', {host: 'localhost', port: 9000});
+      </code></pre>
+      <h3>3. That's it! You're ready to send and receive binary P2P data connections!</h3>
+      <p>Listening for incoming connections:</p>
+      <pre><code>peer.on('connection', function(conn){
+        conn.on('data', function(data) {
+          console.log('Got data:', data);
+        });
+      });
+      </code></pre>
+
+      <p>Create a peer connection:</p>
+      <pre><code>var conn = peer.connect('some-id');
+      conn.on('open', function() {
+        conn.send('Hello world!');
+      });
+      </code></pre>
+
+    <h2>Other cool things you need to know</h2>
+
+      <h3>What kind of data can I send?</h3>
+
+        <p>PeerJS has the BinaryPack serialization format built-in. This means you can send any JSON type as well as binary Blobs and ArrayBuffers. You don't have to worry about serializing yourself. Simple put objects in on one side and get objects out on the other:</p>
+        <pre><code>conn.send({
+          strings: 'hi!',
+          numbers: 150,
+          arrays: [1,2,3],
+          evenbinary: new Blob([1,2,3]),
+          andmore: {bool: true}
+        });
+        </code></pre>
+        <p>With BinaryPack, the data is never converted to strings. Everything is binary end-to-end. This results in bandwidth savings.
+        </p>
+
+      <h3>Preconnection</h3>
+
+        <p>When you try to connect to a peer, PeerServer will hold a connection offer for up to 5 seconds before rejecting it. This is useful if you want to reconnect to a peer as it disconnects and reconnects rapidly between web pages.</p>
+
+      <h3>Connection latency/bandwidth</h3>
+
+        <p>Data sent between the two peers do not touch any other servers, so the connection speed is limited only by the upload and download rates of the two peers. This also means you don't have the additional latency of an intermediary server.</p>
+        <p>The latency to establish a connection is identified by two factors: the brokering of data and identifying of clients. PeerJS has been carefully coded to minimize latency in both applications. Data is brokered through an XHR streaming request before a WebSocket connection is established, then through WebSocket afterwards. Identity is self-provided and thus a new client can report identity, accept an outstanding offer, and and provide answer and thus establish the peer-to-peer connection in very few RTTs.</p>
+        <p>Note that in the infrequent case that both peers are behind symmetric NATs, this is no longer true. See below.</p>
+
+      <h3>Peer-to-peer shortingcomings</h3>
+
+        <p>A very low percentage of users are behind symmetric NATs. When two symmetric NAT users try to connect to each other, NAT traversal is impossible and no connection can be made. A workaround is to proxy through what is known as a TURN server. The PeerServer cloud service does not provide a TURN server. You'll have to find your own. You can pass a TURN server into the <tt>Peer</tt> object options. This will allow your PeerJS app to work seamlessly for this situation</p>
+
+      <h3>Current state of browser compatibility</h3>
+
+        <p><a href="/status">Detailed browser compatibility information</a></p>
+        <p><a href="https://groups.google.com/forum/?fromgroups#!forum/peerjs">Discuss PeerJS on our Google Group</a></p>
+
+  </section>
+</body>