Fix some module naming, fix some flow type errors

Author: basicdays

.eslintignore

@@ -1,3 +1,4 @@
 .idea/
 build/
 flow-typed/
+*.js.flow

.idea/inspectionProfiles/Project_Default.xml

@@ -12,21 +12,21 @@ export const states = {
 };
 
 /**
- * @typedef {Object} StreamAsyncToIterator~Options
+ * @typedef {Object} StreamToAsyncIterator~Options
  * @property {number} [size] - the size of each read from the stream for each iteration
  */
-type StreamAsyncToIteratorOptions = {
+type StreamToAsyncIteratorOptions = {
     size?: number;
 }
 
 /**
- * @typedef {Object} StreamAsyncToIterator~Iteration
+ * @typedef {Object} StreamToAsyncIterator~Iteration
  * @property {boolean} done
- * @property {*} value
+ * @property {*} [value]
  */
-type Iteration = {
+type Iteration<TVal> = {
     done: boolean;
-    value: any;
+    value?: TVal;
 }
 
 type Reject = (err: any) => void;
@@ -38,12 +38,12 @@ type Reject = (err: any) => void;
  * iteration. A size can be supplied to set an explicit call to `stream.read([size])` in
  * the options for each iteration.
  */
-export default class StreamAsyncToIterator {
+export default class StreamToAsyncIterator<TVal> {
     /**
      * @param {Readable} stream
-     * @param {StreamAsyncToIterator~Options} [options]
+     * @param {StreamToAsyncIterator~Options} [options]
      */
-    constructor(stream: Readable, options: StreamAsyncToIteratorOptions={}) {
+    constructor(stream: Readable, options: StreamToAsyncIteratorOptions={}) {
         /**
          * The underlying readable stream
          * @private
@@ -100,23 +100,28 @@ export default class StreamAsyncToIterator {
     _size: ?number;
     _rejections: Set<Reject>;
 
+    //todo: flow is now working with this method in place
+    // [Symbol.asyncIterator]() {
+    //     return this;
+    // }
+
     /**
      * Returns the next iteration of data. Rejects if the stream errored out.
-     * @returns {Promise<StreamAsyncToIterator~Iteration>}
+     * @returns {Promise<StreamToAsyncIterator~Iteration>}
      */
-    async next(): Promise<Iteration> {
+    async next(): Promise<Iteration<TVal>> {
         if (this._state === states.notReadable) {
             //need to wait until the stream is readable or ended
             await Promise.race([this._untilReadable(), this._untilEnd()]);
             return this.next();
         } else if (this._state === states.ended) {
-            return {done: true, value: null};
+            return {done: true};
         } else if (this._state === states.errored) {
             throw this._error;
         } else /* readable */ {
             //stream.read returns null if not readable or when stream has ended
 
-            const data = this._size ? this._stream.read(this._size) : this._stream.read();
+            const data: TVal = this._size ? (this._stream.read(this._size): any) : (this._stream.read(): any);
 
             if (data !== null) {
                 return {done: false, value: data};
@@ -164,7 +169,8 @@ export default class StreamAsyncToIterator {
     }
 }
 
-Object.defineProperty(StreamAsyncToIterator.prototype, (Symbol: any).asyncIterator, {
+//hack: gets around flows inability to handle symbol properties
+Object.defineProperty(StreamToAsyncIterator.prototype, (Symbol: any).asyncIterator, {
     configurable: true,
     value: function() {return this;}
 });

lib/stream-to-async-iterator.js

@@ -1,11 +1,11 @@
 // @flow
 
-declare type StreamAsyncIteratorOptions = {
+declare type StreamToAsyncIteratorOptions = {
     size?: number;
 }
 
-declare export default class StreamAsyncIterator<TData> {
-    constructor(stream: stream$Readable, options?: StreamAsyncIteratorOptions): StreamAsyncIterator<TData>;
-    @@asyncIterator(): $AsyncIterator<TData, void, void>;
-    next(): Promise<IteratorResult<TData, void>>;
+declare export default class StreamToAsyncIterator<TVal> {
+    constructor(stream: stream$Readable, options?: StreamToAsyncIteratorOptions): void;
+    @@asyncIterator(): $AsyncIterator<TVal, void, void>;
+    next(): Promise<IteratorResult<TVal, void>>;
 }

lib/stream-to-async-iterator.js.flow

@@ -1,31 +1,36 @@
 // @flow
-import {describe, it} from 'mocha';
 import fs from 'fs';
 import path from 'path';
-import {expect} from 'chai';
+
+import chai from 'chai';
+import mocha from 'mocha';
+
 import S2A from '../stream-to-async-iterator';
 
+const {expect} = chai;
+const {describe, it} = mocha;
+
 
-describe('StreamAsyncToIterator', () => {
+describe('StreamToAsyncIterator', function() {
     const filePath = path.join(__dirname, 'lorem-ipsum.txt');
 
-    it('should iterate on a node stream', async () => {
+    it('should iterate on a node stream with string encoding', async function() {
         const fileStream = fs.createReadStream(filePath, {encoding: 'utf8'});
-        const buff: Array<string> = [];
+        const buff: string[] = [];
 
-        for await (const value of (new S2A(fileStream): S2A<string>)) {
+        for await (const value of new S2A(fileStream)) {
             buff.push(value);
         }
 
         const content = buff.join('');
         expect(content).to.have.lengthOf(1502);
     });
 
-    it('should iterate on a node stream with a size', async () => {
+    it('should iterate on a node stream with a size with string encoding', async function() {
         const fileStream = fs.createReadStream(filePath, {encoding: 'utf8'});
-        const buff: Array<string> = [];
+        const buff: string[] = [];
 
-        for await (const value of (new S2A(fileStream, {size: 16}): S2A<string>)) {
+        for await (const value of new S2A(fileStream, {size: 16})) {
             buff.push(value);
         }