first commit

Author: mafintosh

.gitignore

@@ -0,0 +1 @@
+node_modules

LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mathias Buus
+
+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.

README.md

@@ -0,0 +1,53 @@
+# random-access-chrome-file
+
+A [random-access-storage](https://github.com/random-access-storage/random-access-storage) instance backed by the Chrome file system api
+
+```
+npm install random-access-chrome-file
+```
+
+## Usage
+
+``` js
+// Currently only works in Chrome
+
+const createFile = require('random-access-chrome-file')
+
+const file = createFile('test.txt')
+
+file.write(0, Buffer.from('hello world'), function (err) {
+  if (err) throw err
+  file.read(0, 11, function (err, buf) {
+    if (err) throw err
+    console.log(buf.toString())
+  })
+})
+```
+
+## API
+
+#### `file = createFile(name, [options])`
+
+Returns a [random-access-storage](https://github.com/random-access-storage/random-access-storage) instance that supports
+the full API.
+
+Options include:
+
+```js
+{
+  maxSize: Number.MAX_SAFE_INTEGER
+}
+```
+
+`maxSize` is the storage quota it asks the browser for. If you are making an extension you can set the `unlimitedStorage`
+to get all the storage you want. Otherwise tweak the `maxSize` option to fit your needs.
+
+If you want to change the `maxSize` default for all instances change `createFile.DEFAULT_MAX_SIZE`.
+
+#### `createFile.requestQuota(maxSize, cb)`
+
+Manually request the `maxSize` quota without creating af file.
+
+## License
+
+MIT

bench.js

@@ -0,0 +1,29 @@
+const createFile = require('./')
+
+const st = createFile('benchmark.txt')
+st.open(benchWrite)
+
+function benchRead () {
+  var offset = 0
+  console.time('512mb read')
+  st.read(0, 65536, function onread (err, buf) {
+    if (err) throw err
+    if (offset >= 512 * 1024 * 1024) return console.timeEnd('512mb read')
+    st.read(offset += buf.length, 65536, onread)
+  })
+}
+
+function benchWrite () {
+  var offset = 0
+  const buf = Buffer.alloc(65536).fill('hi')
+  console.time('512mb write')
+  st.write(offset, buf, function onwrite (err) {
+    if (err) throw err
+    if (offset >= 512 * 1024 * 1024) {
+      console.timeEnd('512mb write')
+      benchRead()
+      return
+    }
+    st.write(offset += buf.length, buf, onwrite)
+  })
+}

example.js

@@ -0,0 +1,12 @@
+const createFile = require('./')
+
+const st = createFile('hello-world.txt')
+var missing = 2
+
+st.write(0, Buffer.from('hello '), done)
+st.write(6, Buffer.from('world'), done)
+
+function done (err) {
+  if (err) throw err
+  if (!--missing) st.read(0, 11, (_, buf) => console.log(buf.toString()))
+}

index.js

@@ -0,0 +1,161 @@
+const ras = require('random-access-storage')
+
+const TYPE = {type: 'octet/stream'}
+const requestFileSystem = window.requestFileSystem || window.webkitRequestFileSystem
+const persistentStorage = navigator.persistentStorage || navigator.webkitPersistentStorage
+const FileReader = window.FileReader
+const Blob = window.Blob
+
+createFile.DEFAULT_MAX_SIZE = Number.MAX_SAFE_INTEGER
+createFile.requestQuota = requestQuota
+
+module.exports = createFile
+
+function requestQuota (n, force, cb) {
+  if (typeof force === 'function') return requestQuota(n, true, force)
+  persistentStorage.queryUsageAndQuota(function (used, quota) {
+    if (quota && !force) return cb(null, quota)
+    persistentStorage.requestQuota(n, function (quota) {
+      cb(null, quota)
+    }, cb)
+  }, cb)
+}
+
+function createFile (name, opts) {
+  if (!opts) opts = {}
+
+  const maxSize = opts.maxSize || createFile.DEFAULT_MAX_SIZE
+  const waiting = []
+  const writers = []
+  const readers = []
+
+  var fs = null
+  var file = null
+  var entry = null
+  var truncate = null
+  var totalWriters = 0
+
+  return ras({read, write, open, stat, close})
+
+  function wait (req) {
+    waiting.push(req)
+  }
+
+  function allocWriter (req) {
+    const io = {writer: null, req: null}
+
+    entry.createWriter(function (writer) {
+      io.writer = writer
+      io.writer.onerror = function (err) {
+        onwrite(err)
+      }
+      io.writer.onwriteend = function () {
+        onwrite(null)
+      }
+
+      writers.push(io)
+      totalWriters++
+      write(req)
+    }, onallocerror)
+
+    function onallocerror (err) {
+      req.callback(err)
+    }
+
+    function onwrite (err) {
+      const req = io.req
+      io.req = null
+      writers.push(io)
+
+      if (truncate) {
+        if (io === truncate) {
+          truncate = null
+          while (waiting.length) write(waiting.pop())
+          write(req)
+          return
+        }
+
+        if (totalWriters - writers.length === 1) {
+          truncate.writer.truncate(truncate.req.offset)
+        }
+      }
+
+      req.callback(err, null)
+    }
+  }
+
+  function allocReader () {
+    const io = {reader: null, req: null}
+
+    io.reader = new FileReader()
+    io.reader.onerror = function (err) {
+      onread(err, null)
+    }
+    io.reader.onload = function () {
+      onread(null, Buffer.from(this.result))
+    }
+
+    return io
+
+    function onread (err, buf) {
+      const req = io.req
+      io.req = null
+      readers.push(io)
+      req.callback(err, buf)
+    }
+  }
+
+  function read (req) {
+    const io = readers.pop() || allocReader()
+    io.req = req
+    io.reader.readAsArrayBuffer(file.slice(req.offset, req.offset + req.size))
+  }
+
+  function close (req) {
+    entry = file = fs = null
+    req.callback(null)
+  }
+
+  function write (req) {
+    if (truncate) return wait(req)
+
+    const io = writers.pop()
+    if (!io) return allocWriter(req)
+
+    io.req = req
+
+    if (req.offset > file.size) {
+      truncate = io
+      if (totalWriters - writers.length === 1) io.writer.truncate(req.offset)
+      return
+    }
+
+    io.writer.seek(req.offset)
+    io.writer.write(new Blob([req.data], TYPE))
+  }
+
+  function stat (req) {
+    req.callback(null, file)
+  }
+
+  function open (req) {
+    requestQuota(maxSize, false, function (err, granted) {
+      if (err) return onerror(err)
+      requestFileSystem(window.PERSISTENT, granted, function (res) {
+        fs = res
+        fs.root.getFile(name, {create: true}, function (e) {
+          entry = e
+          entry.file(function (f) {
+            file = f
+            req.callback(null)
+          }, onerror)
+        }, onerror)
+      }, onerror)
+    })
+
+    function onerror (err) {
+      fs = file = entry = null
+      req.callback(err)
+    }
+  }
+}

package.json

@@ -0,0 +1,25 @@
+{
+  "name": "random-access-chrome-file",
+  "version": "0.0.0",
+  "description": "random-access-storage instance backed by the Chrome file system api.",
+  "main": "index.js",
+  "dependencies": {
+    "random-access-storage": "^1.3.0"
+  },
+  "devDependencies": {
+    "standard": "^11.0.1"
+  },
+  "scripts": {
+    "test": "standard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mafintosh/random-access-chrome-file.git"
+  },
+  "author": "Mathias Buus (@mafintosh)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mafintosh/random-access-chrome-file/issues"
+  },
+  "homepage": "https://github.com/mafintosh/random-access-chrome-file"
+}