@ohos-ports/whatwg-streams 0.1.1-beta.1

package/LICENCE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Raynos.
+
+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,38 @@
+# whatwg-streams
+
+[![build status][1]][2] [![NPM version][3]][4] [![Coverage Status][5]][6] [![Davis Dependency status][9]][10]
+
+[![browser support][11]][12]
+
+An implementation of the whatwg/streams spec
+
+## Example
+
+```js
+var whatwgStreams = require("whatwg-streams")
+
+// TODO. Show example
+```
+
+## Installation
+
+`npm install whatwg-streams`
+
+## Contributors
+
+ - Raynos
+
+## MIT Licenced
+
+  [1]: https://secure.travis-ci.org/Raynos/whatwg-streams.png
+  [2]: https://travis-ci.org/Raynos/whatwg-streams
+  [3]: https://badge.fury.io/js/whatwg-streams.png
+  [4]: https://badge.fury.io/js/whatwg-streams
+  [5]: https://coveralls.io/repos/Raynos/whatwg-streams/badge.png
+  [6]: https://coveralls.io/r/Raynos/whatwg-streams
+  [7]: https://gemnasium.com/Raynos/whatwg-streams.png
+  [8]: https://gemnasium.com/Raynos/whatwg-streams
+  [9]: https://david-dm.org/Raynos/whatwg-streams.png
+  [10]: https://david-dm.org/Raynos/whatwg-streams
+  [11]: https://ci.testling.com/Raynos/whatwg-streams.png
+  [12]: https://ci.testling.com/Raynos/whatwg-streams

package/base-readable.js

@@ -0,0 +1,53 @@
+var ReadableStreamState = require("./readable/stream-state.js")
+var constructor = require("./readable/constructor.js")
+var read = require("./readable/read.js")
+var waitForReadable = require("./readable/wait-for-readable.js")
+var abort = require("./readable/abort.js")
+
+var defineProperty = Object.defineProperty
+
+function BaseReadableStream(options) {
+    if (!(this instanceof BaseReadableStream)) {
+        return new BaseReadableStream(options)
+    }
+
+    this._state = new ReadableStreamState(options)
+
+    constructor(this._state, options.start)
+}
+
+var proto = BaseReadableStream.prototype
+
+proto.read = function protoRead() {
+    return read(this._state)
+}
+
+proto.waitForReadable = function protoWaitForReadable() {
+    return waitForReadable(this._state)
+}
+
+defineProperty(proto, "readableState", {
+    configurable: true,
+    get: function getReadableState() {
+        return this._state.readableState
+    }
+})
+
+proto.abort = function protoAbort(reason) {
+    return abort(this._state, reason)
+}
+
+defineProperty(proto, "finished", {
+    configurable: true,
+    get: function getFinished() {
+        return this._state.finished
+    }
+})
+
+// TODO IMPLEMENT
+proto.pipe = function protoPipe() {}
+
+module.exports = BaseReadableStream
+
+
+

package/base-writable.js

@@ -0,0 +1,52 @@
+var WritableStreamState = require("./writable/stream-state.js")
+var constructor = require("./writable/constructor.js")
+var write = require("./writable/write.js")
+var waitForWritable = require("./writable/wait-for-writable.js")
+var close = require("./writable/close.js")
+var dispose = require("./writable/dispose.js")
+
+var defineProperty = Object.defineProperty
+
+function BaseWritableStream(options) {
+    if (!(this instanceof BaseWritableStream)) {
+        return new BaseWritableStream(options)
+    }
+
+    this._state =  new WritableStreamState(options)
+
+    constructor(this._state, options.start)
+}
+
+var proto = BaseWritableStream.prototype
+
+proto.write = function protoWrite(chunk) {
+    return write(this._state, chunk)
+}
+
+proto.waitForWritable = function protoWaitForWritable() {
+    return waitForWritable(this._state)
+}
+
+defineProperty(proto, "writableState", {
+    configurable: true,
+    get: function getWritableState() {
+        return this._state.writableState
+    }
+})
+
+proto.close = function protoClose() {
+    return close(this._state)
+}
+
+proto.dispose = function protoDispose(reason) {
+    return dispose(this._state, reason)
+}
+
+defineProperty(proto, "closed", {
+    configurable: true,
+    get: function getClose() {
+        return this._state.closedPromise
+    }
+})
+
+module.exports = BaseWritableStream

package/index.js

@@ -0,0 +1,13 @@
+// Main entry restored as part of the HarmonyOS migration: the 0.1.1 npm
+// tarball (and the upstream v0.1.1 tag) ship no index.js even though
+// package.json declares "main": "index".
+//
+// At v0.1.1 only the readable half of the package is complete:
+// base-writable.js requires writable/write.js, writable/wait-for-writable.js,
+// writable/close.js and writable/dispose.js, none of which exist in the
+// published package or in the upstream v0.1.1 tag (writable/constructor.js is
+// an empty function upstream). Requiring base-writable here would therefore
+// throw MODULE_NOT_FOUND, so this entry only exports BaseReadableStream.
+module.exports = {
+    BaseReadableStream: require("./base-readable.js")
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ohos-ports/whatwg-streams",
+  "version": "0.1.1-beta.1",
+  "description": "An implementation of the whatwg/streams spec",
+  "keywords": [],
+  "author": "Raynos <raynos2@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ohos-ports/ohos-ports.git",
+    "directory": "ports/whatwg-streams/0.1.1"
+  },
+  "main": "index",
+  "homepage": "https://github.com/Raynos/whatwg-streams",
+  "contributors": [
+    {
+      "name": "Raynos"
+    }
+  ],
+  "bugs": {
+    "url": "https://github.com/ohos-ports/ohos-ports/issues",
+    "email": "raynos2@gmail.com"
+  },
+  "dependencies": {
+    "tape": "~2.3.2",
+    "bluebird": "~1.0.0"
+  },
+  "devDependencies": {
+    "tape": "~1.0.2"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/Raynos/whatwg-streams/raw/master/LICENSE"
+    }
+  ],
+  "scripts": {
+    "test": "node ./test/index.js",
+    "start": "node ./index.js",
+    "watch": "nodemon -w ./index.js index.js",
+    "travis-test": "istanbul cover ./test/index.js && ((cat coverage/lcov.info | coveralls) || exit 0)",
+    "cover": "istanbul cover --report none --print detail ./test/index.js",
+    "view-cover": "istanbul report html && google-chrome ./coverage/index.html",
+    "test-browser": "testem-browser ./test/browser/index.js",
+    "testem": "testem-both -b=./test/browser/index.js"
+  },
+  "testling": {
+    "files": "test/index.js",
+    "browsers": [
+      "ie/8..latest",
+      "firefox/16..latest",
+      "firefox/nightly",
+      "chrome/22..latest",
+      "chrome/canary",
+      "opera/12..latest",
+      "opera/next",
+      "safari/5.1..latest",
+      "ipad/6.0..latest",
+      "iphone/6.0..latest",
+      "android-browser/4.2..latest"
+    ]
+  }
+}

package/readable/abort.js

@@ -0,0 +1,27 @@
+var Promise = require("bluebird")
+
+module.exports = abort
+
+function abort(streamState, reason) {
+    // NON STANDARD
+    if (streamState.readableState === "finished") {
+        throw new Error("cannot abort finished stream")
+    // NON STANDARD
+    } else if (streamState.readableState === "errored") {
+        throw new Error("cannot abort errored stream")
+    }
+
+    streamState.onAbort(reason)
+    streamState.finishedPromise._fulfill(undefined)
+    // should this be errored ?
+    streamState.readableState = "finished"
+
+    if (streamState.readableState === "waiting") {
+        // Question: should `reason` be cast to an `Error` object
+        // if it's a string
+        streamState.readablePromise._reject(reason)
+    } else if (streamState.readableState === "readable") {
+        streamState.readablePromise = Promise.rejected(reason)
+        streamState.buffer.length = 0
+    }
+}

package/readable/call-pull.js

@@ -0,0 +1,27 @@
+var push = require("./push.js")
+var finish = require("./finish.js")
+var error = require("./error.js")
+
+module.exports = callPull
+
+function callPull(streamState) {
+    if (streamState.pulling) {
+        return
+    }
+
+    if (streamState.started) {
+        streamState.onPull(
+            push.bind(null, streamState),
+            finish.bind(null, streamState),
+            error.bind(null, streamState)
+        )
+    } else {
+        streamState.startedPromise.then(function () {
+            streamState.onPull(
+                push.bind(null, streamState),
+                finish.bind(null, streamState),
+                error.bind(null, streamState)
+            )
+        })
+    }
+}

package/readable/constructor.js

@@ -0,0 +1,26 @@
+var Promise = require("bluebird")
+
+var error = require("./error.js")
+var push = require("./push.js")
+var finish = require("./finish.js")
+
+module.exports = constructor
+
+function constructor(streamState, start) {
+    var value = start(
+        push.bind(null, streamState),
+        finish.bind(null, streamState),
+        error.bind(null, streamState)
+    )
+
+    var startedPromise = streamState.startedPromise = Promise.cast(value)
+    startedPromise.then(onFulfill, onReject)
+
+    function onFulfill() {
+        streamState.started = true
+    }
+
+    function onReject(reason) {
+        error(streamState, reason)
+    }
+}

package/readable/error.js

@@ -0,0 +1,25 @@
+var Promise = require("bluebird")
+
+module.exports = error
+
+function error(streamState, err) {
+    // NON STANDARD
+    if (streamState.readableState === "errored") {
+        throw new Error("cannot error() a stream in errored state")
+    // NON STANDARD
+    } else if (streamState.readableState === "finished") {
+        throw new Error("cannot error() a stream in finished state")
+    }
+
+    streamState.storedError = err
+    streamState.finishedPromise._reject(err)
+    streamState.readableState = "errored"
+
+    // Question: check err is instanceof Error ???
+    if (streamState.readableState === "waiting") {
+        streamState.readablePromise._reject(err)
+    } else if (streamState.readableState === "readable") {
+        streamState.buffer = []
+        streamState.readablePromise = Promise.rejected(err)
+    }
+}

package/readable/finish.js

@@ -0,0 +1,20 @@
+module.exports = finish
+
+function finish(streamState) {
+    // NON STANDARD
+    if (streamState.readableState === "finished") {
+        throw new Error("cannot finish finished stream")
+    // NON STANDARD
+    } else if (streamState.readableState === "errored") {
+        throw new Error("cannot finish errored stream")
+    }
+
+    if (streamState.readableState === "waiting") {
+        streamState.readablePromise._reject(
+            new Error("stream has been completely read"))
+        streamState.finishedPromise._fulfill(undefined)
+        streamState.readableState = "finished"
+    } else if (streamState.readableState === "readable") {
+        streamState.draining = true
+    }
+}

package/readable/push.js

@@ -0,0 +1,23 @@
+module.exports = push
+
+function push(streamState, data) {
+    // NON STANDARD
+    if (streamState.readableState === "finished") {
+        throw new Error("cannot push into finished stream")
+    // NON STANDARD
+    } else if (streamState.readableState === "errored") {
+        throw new Error("cannot push into errored stream")
+    }
+
+    streamState.buffer.push(data)
+    streamState.pulling = false
+
+    if (streamState.readableState === "waiting") {
+        streamState.readablePromise._fulfill(undefined)
+        streamState.readableState = "readable"
+    }
+
+    // NON STANDARD
+    var needsMore = false
+    return needsMore
+}

package/readable/read.js

@@ -0,0 +1,34 @@
+var assert = require("assert")
+var Promise = require("bluebird")
+
+var callPull = require("./call-pull.js");
+
+module.exports = read
+
+function read(streamState) {
+    if (streamState.readableState === "waiting") {
+        throw new Error("no data available yet")
+    } else if (streamState.readableState === "errored") {
+        throw streamState.storedError
+    } else if (streamState.readableState === "finished") {
+        throw new Error("stream has been completely read")
+    }
+
+    assert(streamState.buffer.length !== 0, "buffer is empty")
+    var data = streamState.buffer.shift()
+
+    if (streamState.buffer.length === 0) {
+        if (streamState.draining) {
+            streamState.finishedPromise._fulfill(undefined)
+            streamState.readablePromise =
+                Promise.rejected(new Error("stream has been completely read"))
+            streamState.readableState = "finished"
+        } else {
+            streamState.readableState = "waiting"
+            streamState.readablePromise = new Promise(function () {})
+            callPull(streamState)
+        }
+    }
+
+    return data
+}

package/readable/stream-state.js

@@ -0,0 +1,17 @@
+var Promise = require("bluebird")
+
+module.exports = ReadableStreamState
+
+function ReadableStreamState(options) {
+    this.buffer = []
+    this.started = false
+    this.draining = false
+    this.pulling = false
+    this.readableState = "waiting"
+    this.storedError = null
+    this.readablePromise = new Promise(function () {})
+    this.finishedPromise = new Promise(function () {})
+    this.startedPromise = new Promise(function () {})
+    this.onAbort = options.abort
+    this.onPull = options.pull
+}

package/readable/wait-for-readable.js

@@ -0,0 +1,11 @@
+var callPull = require("./call-pull.js")
+
+module.exports = waitForReadable
+
+function waitForReadable(streamState) {
+    if (streamState.readableState === "waiting") {
+        callPull(streamState)
+    }
+
+    return streamState.readablePromise
+}

package/writable/constructor.js

@@ -0,0 +1,5 @@
+module.exports = constructor
+
+function constructor(streamState, start) {
+    
+}

package/writable/stream-state.js

@@ -0,0 +1,15 @@
+var Promise = require("bluebird")
+
+module.exports = WritableStreamState
+
+function WritableStreamState(options) {
+    this.buffer = []
+    this.writableState = "waiting"
+    this.storedError = null
+    this.currentWritePromise = new Promise(function () {})
+    this.writablePromise = new Promise(function () {})
+    this.closedPromise = new Promise(function () {})
+    this.onWrite = options.write
+    this.onClose = options.close
+    this.onDispose = options.dispose || options.close
+}