format

Author: mafintosh

README.md

@@ -8,11 +8,11 @@ Built for sharing large datasets and streams of real time data
 
 ## Features
 
-* **Sparse replication.** Only download the data you are interested in.
-* **Realtime.** Get the latest updates to the log fast and securely.
-* **Performant.** Uses a simple flat file structure to maximize I/O performance.
-* **Secure.** Uses signed merkle trees to verify log integrity in real time.
-* **Modular.** Hypercore aims to do one thing and one thing well - distributing a stream of data.
+- **Sparse replication.** Only download the data you are interested in.
+- **Realtime.** Get the latest updates to the log fast and securely.
+- **Performant.** Uses a simple flat file structure to maximize I/O performance.
+- **Secure.** Uses signed merkle trees to verify log integrity in real time.
+- **Modular.** Hypercore aims to do one thing and one thing well - distributing a stream of data.
 
 Note that the latest release is Hypercore 10, which adds support for truncate and many other things.
 Version 10 is not compatible with earlier versions (9 and earlier), but is considered LTS, meaning the storage format and wire protocol is forward compatible with future versions.
@@ -31,7 +31,7 @@ Make a new Hypercore instance.
 
 `storage` should be set to a directory where you want to store the data and core metadata.
 
-``` js
+```js
 const core = new Hypercore('./directory') // store data in ./directory
 ```
 
@@ -41,7 +41,7 @@ Alternatively you can pass a [Hypercore Storage](https://github.com/holepunchto/
 
 `options` include:
 
-``` js
+```js
 {
   createIfMissing: true, // create a new Hypercore key pair if none was present in storage
   overwrite: false, // overwrite any old Hypercore that might already exist
@@ -114,7 +114,7 @@ Signers are an array of objects with the following structure:
 Append a block of data (or an array of blocks) to the core.
 Returns the new length and byte length of the core.
 
-``` js
+```js
 // simple call append with a new block of data
 await core.append(Buffer.from('I am a block of data'))
 
@@ -138,7 +138,7 @@ await core.append([Buffer.from('batch block 1'), Buffer.from('batch block 2')])
 Get a block of data.
 If the data is not available locally this method will prioritize and wait for the data to be downloaded.
 
-``` js
+```js
 // get block #42
 const block = await core.get(42)
 
@@ -151,7 +151,7 @@ const blockLocal = await core.get(44, { wait: false })
 
 `options` include:
 
-``` js
+```js
 {
   wait: true, // wait for block to be downloaded
   onwait: () => {}, // hook that is called if the get is waiting for download
@@ -171,15 +171,15 @@ Check if the core has all blocks between `start` and `end`.
 
 Waits for initial proof of the new core length until all `findingPeers` calls has finished.
 
-``` js
+```js
 const updated = await core.update()
 
 console.log('core was updated?', updated, 'length is', core.length)
 ```
 
 `options` include:
 
-``` js
+```js
 {
   wait: false,
   activeRequests: undefined, // Advanced option. Pass requests for replicating blocks
@@ -196,15 +196,15 @@ Seek to a byte offset.
 Returns `[index, relativeOffset]`, where `index` is the data block the `byteOffset` is contained in and `relativeOffset` is
 the relative byte offset in the data block.
 
-``` js
+```js
 await core.append([Buffer.from('abc'), Buffer.from('d'), Buffer.from('efg')])
 
 const first = await core.seek(1) // returns [0, 1]
 const second = await core.seek(3) // returns [1, 0]
 const third = await core.seek(5) // returns [2, 1]
 ```
 
-``` js
+```js
 {
   wait: true, // wait for data to be downloaded
   timeout: 0, // wait at max some milliseconds (0 means no timeout)
@@ -216,7 +216,7 @@ const third = await core.seek(5) // returns [2, 1]
 
 Make a read stream to read a range of data out at once.
 
-``` js
+```js
 // read the full core
 const fullStream = core.createReadStream()
 
@@ -233,7 +233,7 @@ for await (const data of fullStream) {
 
 `options` include:
 
-``` js
+```js
 {
   start: 0,
   end: core.length,
@@ -248,7 +248,7 @@ for await (const data of fullStream) {
 
 Make a byte stream to read a range of bytes.
 
-``` js
+```js
 // Read the full core
 const fullStream = core.createByteStream()
 
@@ -266,7 +266,7 @@ partialStream.pipe(process.stdout)
 
 `options` include:
 
-``` js
+```js
 {
   byteOffset: 0, // Offset where to start from
   byteLength: core.byteLength - options.byteOffset, // How many bytes to read
@@ -278,11 +278,11 @@ partialStream.pipe(process.stdout)
 
 Make a write stream to append chunks as blocks.
 
-``` js
+```js
 const ws = core.createWriteStream()
 
 // Listen for stream finishing
-const done = new Promise(resolve => ws.on('finish', resolve))
+const done = new Promise((resolve) => ws.on('finish', resolve))
 
 for (const data of ['hello', 'world']) ws.write(data)
 ws.end()
@@ -297,14 +297,15 @@ console.log(await core.get(core.length - 1)) // 'world'
 
 Clear stored blocks between `start` and `end`, reclaiming storage when possible.
 
-``` js
+```js
 await core.clear(4) // clear block 4 from your local cache
 await core.clear(0, 10) // clear block 0-10 from your local cache
 ```
 
 The core will also gossip to peers it is connected to, that is no longer has these blocks.
 
 `options` include:
+
 ```js
 {
   diff: false // Returned `cleared` bytes object is null unless you enable this
@@ -319,6 +320,7 @@ Per default this will update the fork id of the core to `+ 1`, but you can set t
 Note that the fork id should be monotonely incrementing.
 
 `options` include:
+
 ```js
 {
   fork: core.fork + 1, // The new fork id after truncating
@@ -372,7 +374,7 @@ await range.done()
 
 A range can have the following properties:
 
-``` js
+```js
 {
   start: startIndex,
   end: nonInclusiveEndIndex,
@@ -384,7 +386,7 @@ A range can have the following properties:
 
 To download the full core continuously (often referred to as non sparse mode) do
 
-``` js
+```js
 // Note that this will never be considered downloaded as the range
 // will keep waiting for new blocks to be appended.
 core.download({ start: 0, end: -1 })
@@ -398,7 +400,7 @@ core.download({ blocks: [4, 9, 7] })
 
 To cancel downloading a range simply destroy the range instance.
 
-``` js
+```js
 // will stop downloading now
 range.destroy()
 ```
@@ -504,10 +506,10 @@ Info {
   fork: 0,
   padding: 8,
   storage: {
-    oplog: 8192, 
-    tree: 4096, 
-    blocks: 4096, 
-    bitfield: 4096 
+    oplog: 8192,
+    tree: 4096,
+    blocks: 4096,
+    bitfield: 4096
   }
 }
 ```
@@ -660,7 +662,7 @@ If you are using a P2P swarm like [Hyperswarm](https://github.com/hyperswarm/hyp
 If you want to multiplex the replication over an existing Hypercore replication stream you can pass
 another stream instance instead of the `isInitiator` boolean.
 
-``` js
+```js
 // assuming we have two cores, localCore + remoteCore, sharing the same key
 // on a server
 const net = require('net')

examples/announce.js

@@ -5,14 +5,14 @@ const core = new Hypercore('./source')
 
 start()
 
-async function start () {
+async function start() {
   await core.ready()
   while (core.length < 1000) {
     await core.append('block #' + core.length)
   }
 
   const swarm = new Hyperswarm()
-  swarm.on('connection', socket => core.replicate(socket))
+  swarm.on('connection', (socket) => core.replicate(socket))
   swarm.join(core.discoveryKey, { server: true, client: false })
 
   console.log('Core:', core.key.toString('hex'))

examples/basic.js

@@ -2,7 +2,7 @@ const Hypercore = require('../')
 
 start()
 
-async function start () {
+async function start() {
   const core = new Hypercore('/tmp/basic')
   await core.append(['Hello', 'World'])
   console.log(core)

examples/http.js

@@ -7,13 +7,14 @@ const rangeParser = require('range-parser')
 // Later replicate so other peers can also watch it: node http.js
 // Other peers: node http.js <core key>
 
-const key = process.argv[2] && process.argv[2] !== 'import' ? Buffer.from(process.argv[2], 'hex') : null
+const key =
+  process.argv[2] && process.argv[2] !== 'import' ? Buffer.from(process.argv[2], 'hex') : null
 const core = new Hypercore('/tmp/movie' + (key ? '-peer' : ''), key)
 
 if (process.argv[2] === 'import') importData(process.argv[3])
 else start()
 
-async function start () {
+async function start() {
   await core.ready()
   if (core.writable) console.log('Share this core key:', core.key.toString('hex'))
 
@@ -33,46 +34,51 @@ async function start () {
     await core.update()
   }
 
-  http.createServer(function (req, res) {
-    res.setHeader('Content-Type', 'video/mp4')
-    res.setHeader('Accept-Ranges', 'bytes')
+  http
+    .createServer(function (req, res) {
+      res.setHeader('Content-Type', 'video/mp4')
+      res.setHeader('Accept-Ranges', 'bytes')
 
-    let byteOffset = 0
-    let byteLength = core.byteLength
+      let byteOffset = 0
+      let byteLength = core.byteLength
 
-    if (req.headers.range) {
-      const ranges = rangeParser(core.byteLength, req.headers.range)
+      if (req.headers.range) {
+        const ranges = rangeParser(core.byteLength, req.headers.range)
 
-      if (ranges === -1 || ranges === -2) {
-        res.statusCode = 206
-        res.setHeader('Content-Length', 0)
-        res.end()
-        return
-      }
+        if (ranges === -1 || ranges === -2) {
+          res.statusCode = 206
+          res.setHeader('Content-Length', 0)
+          res.end()
+          return
+        }
 
-      const range = ranges[0]
-      byteOffset = range.start
-      byteLength = range.end - range.start + 1
+        const range = ranges[0]
+        byteOffset = range.start
+        byteLength = range.end - range.start + 1
 
-      res.statusCode = 206
-      res.setHeader('Content-Range', 'bytes ' + range.start + '-' + range.end + '/' + core.byteLength)
-    }
+        res.statusCode = 206
+        res.setHeader(
+          'Content-Range',
+          'bytes ' + range.start + '-' + range.end + '/' + core.byteLength
+        )
+      }
 
-    res.setHeader('Content-Length', byteLength)
+      res.setHeader('Content-Length', byteLength)
 
-    if (req.method === 'HEAD') {
-      res.end()
-      return
-    }
+      if (req.method === 'HEAD') {
+        res.end()
+        return
+      }
 
-    const bs = core.createByteStream({ byteOffset, byteLength })
-    bs.pipe(res, noop)
-  }).listen(function () {
-    console.log('HTTP server on http://localhost:' + this.address().port)
-  })
+      const bs = core.createByteStream({ byteOffset, byteLength })
+      bs.pipe(res, noop)
+    })
+    .listen(function () {
+      console.log('HTTP server on http://localhost:' + this.address().port)
+    })
 }
 
-async function importData (filename) {
+async function importData(filename) {
   const fs = require('fs')
   const rs = fs.createReadStream(filename)
 
@@ -83,4 +89,4 @@ async function importData (filename) {
   console.log('done!', core)
 }
 
-function noop () {}
+function noop() {}

examples/lookup.js

@@ -5,11 +5,11 @@ const core = new Hypercore('./clone', process.argv[2])
 
 start()
 
-async function start () {
+async function start() {
   await core.ready()
 
   const swarm = new Hyperswarm()
-  swarm.on('connection', socket => core.replicate(socket))
+  swarm.on('connection', (socket) => core.replicate(socket))
   swarm.join(core.discoveryKey, { server: false, client: true })
 
   console.log((await core.get(42)).toString())