replacing bluebird with native promises

package.json

@@ -265,7 +265,6 @@
     "node": ">=4.0.0"
   },
   "devDependencies": {
-    "@types/bluebird": "^3.5.20",
     "@types/mocha": "^5.2.0",
     "@types/node": "^10.0.1",
     "babel-plugin-syntax-dynamic-import": "^6.18.0",
@@ -281,7 +280,6 @@
     "webpack-cli": "^3.1.0"
   },
   "dependencies": {
-    "bluebird": "^3.5.1",
     "lodash": "^4.17.15",
     "strip-bom": "^2.0.0"
   },

src/Converter.ts

@@ -1,7 +1,7 @@
 import { Transform, TransformOptions, Readable } from "stream";
 import { CSVParseParam, mergeParams } from "./Parameters";
 import { ParseRuntime, initParseRuntime } from "./ParseRuntime";
-import P from "bluebird";
+
 import { stringToLines } from "./fileline";
 import { map } from "lodash/map";
 import { RowSplit, RowSplitResult } from "./rowSplit";
@@ -74,7 +74,7 @@ export class Converter extends Transform implements PromiseLike<any[]> {
     return this.fromStream(read);
   }
   then<TResult1 = any[], TResult2 = never>(onfulfilled?: (value: any[]) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2> {
-    return new P((resolve, reject) => {
+    return new Promise((resolve, reject) => {
       this.parseRuntime.then = {
         onfulfilled: (value: any[]) => {
           if (onfulfilled) {

src/ProcessFork.ts

@@ -1,5 +1,5 @@
 import { Processor, ProcessLineResult } from "./Processor";
-import P from "bluebird"
+
 import { Converter } from "./Converter";
 import { ChildProcess } from "child_process";
 import { CSVParseParam, mergeParams } from "./Parameters";
@@ -9,8 +9,8 @@ import { bufFromString, emptyBuffer } from "./util";
 import CSVError from "./CSVError";
 
 export class ProcessorFork extends Processor {
-  flush(): P<ProcessLineResult[]> {
-    return new P((resolve, reject) => {
+  flush(): Promise<ProcessLineResult[]> {
+    return new Promise((resolve, reject) => {
       // console.log("flush");
       this.finalChunk = true;
       this.next = resolve;
@@ -21,9 +21,9 @@ export class ProcessorFork extends Processor {
       // })
     });
   }
-  destroy(): P<void> {
+  destroy(): Promise<void> {
     this.childProcess.kill();
-    return P.resolve();
+    return Promise.resolve();
   }
   childProcess: ChildProcess;
   inited: boolean = false;
@@ -124,8 +124,8 @@ export class ProcessorFork extends Processor {
     // console.log("buf length",this.resultBuf.length);
   }
 
-  process(chunk: Buffer): P<ProcessLineResult[]> {
-    return new P((resolve, reject) => {
+  process(chunk: Buffer): Promise<ProcessLineResult[]> {
+    return new Promise((resolve, reject) => {
       // console.log("chunk", chunk.length);
       this.next = resolve;
       // this.appendReadBuf(chunk);

src/Processor.ts

@@ -1,5 +1,5 @@
 import { Converter } from "./Converter";
-import P from "bluebird";
+
 import { JSONResult } from "./lineToJson";
 import { CSVParseParam } from "./Parameters";
 import { ParseRuntime } from "./ParseRuntime";
@@ -11,8 +11,8 @@ export abstract class Processor {
     this.params = converter.parseParam;
     this.runtime = converter.parseRuntime;
   }
-  abstract process(chunk: Buffer,finalChunk?:boolean): P<ProcessLineResult[]>
-  abstract destroy():P<void>;
-  abstract flush(): P<ProcessLineResult[]>;
+  abstract process(chunk: Buffer,finalChunk?:boolean): Promise<ProcessLineResult[]>
+  abstract destroy():Promise<void>;
+  abstract flush(): Promise<ProcessLineResult[]>;
 }
 export type ProcessLineResult = string | string[] | JSONResult;

src/ProcessorLocal.test.ts

@@ -1,6 +1,6 @@
 import {ProcessorLocal} from "./ProcessorLocal";
 import { Converter } from "./Converter";
-import P from "bluebird";
+
 import {readFileSync} from "fs";
 import path from "path";
 import assert from "assert";

src/ProcessorLocal.ts

@@ -1,5 +1,5 @@
 import { Processor, ProcessLineResult } from "./Processor";
-import P from "bluebird";
+
 import { prepareData } from "./dataClean";
 import getEol from "./getEol";
 import { stringToLines } from "./fileline";
@@ -12,24 +12,24 @@ import CSVError from "./CSVError";
 
 
 export class ProcessorLocal extends Processor {
-  flush(): P<ProcessLineResult[]> {
+  flush(): Promise<ProcessLineResult[]> {
     if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {
       const buf = this.runtime.csvLineBuffer;
       this.runtime.csvLineBuffer = undefined;
       return this.process(buf, true)
         .then((res) => {
           if (this.runtime.csvLineBuffer && this.runtime.csvLineBuffer.length > 0) {
-            return P.reject(CSVError.unclosed_quote(this.runtime.parsedLineNumber, this.runtime.csvLineBuffer.toString()))
+            return Promise.reject(CSVError.unclosed_quote(this.runtime.parsedLineNumber, this.runtime.csvLineBuffer.toString()))
           } else {
-            return P.resolve(res);
+            return Promise.resolve(res);
           }
         })
     } else {
-      return P.resolve([]);
+      return Promise.resolve([]);
     }
   }
-  destroy(): P<void> {
-    return P.resolve();
+  destroy(): Promise<void> {
+    return Promise.resolve();
   }
   private rowSplit: RowSplit = new RowSplit(this.converter);
   private eolEmitted = false;
@@ -49,15 +49,15 @@ export class ProcessorLocal extends Processor {
     return this._needEmitHead;
 
   }
-  process(chunk: Buffer, finalChunk = false): P<ProcessLineResult[]> {
+  process(chunk: Buffer, finalChunk = false): Promise<ProcessLineResult[]> {
     let csvString: string;
     if (finalChunk) {
       csvString = chunk.toString();
     } else {
       csvString = prepareData(chunk, this.converter.parseRuntime);
 
     }
-    return P.resolve()
+    return Promise.resolve()
       .then(() => {
         if (this.runtime.preRawDataHook) {
           return this.runtime.preRawDataHook(csvString);
@@ -69,11 +69,11 @@ export class ProcessorLocal extends Processor {
         if (csv && csv.length > 0) {
           return this.processCSV(csv, finalChunk);
         } else {
-          return P.resolve([]);
+          return Promise.resolve([]);
         }
       })
   }
-  private processCSV(csv: string, finalChunk: boolean): P<ProcessLineResult[]> {
+  private processCSV(csv: string, finalChunk: boolean): Promise<ProcessLineResult[]> {
     const params = this.params;
     const runtime = this.runtime;
     if (!runtime.eol) {
@@ -95,11 +95,11 @@ export class ProcessorLocal extends Processor {
       stringToLineResult.partial = "";
     }
     if (stringToLineResult.lines.length > 0) {
-      let prom: P<string[]>;
+      let prom: Promise<string[]>;
       if (runtime.preFileLineHook) {
         prom = this.runPreLineHook(stringToLineResult.lines);
       } else {
-        prom = P.resolve(stringToLineResult.lines);
+        prom = Promise.resolve(stringToLineResult.lines);
       }
       return prom.then((lines) => {
         if (!runtime.started
@@ -114,7 +114,7 @@ export class ProcessorLocal extends Processor {
 
     } else {
 
-      return P.resolve([]);
+      return Promise.resolve([]);
     }
 
   }
@@ -227,8 +227,8 @@ export class ProcessorLocal extends Processor {
     }
 
   }
-  private runPreLineHook(lines: string[]): P<string[]> {
-    return new P((resolve, reject) => {
+  private runPreLineHook(lines: string[]): Promise<string[]> {
+    return new Promise((resolve, reject) => {
       processLineHook(lines, this.runtime, 0, (err) => {
         if (err) {
           reject(err);

src/Result.test.ts

@@ -1,6 +1,6 @@
 import {Result} from "./Result";
 import { Converter } from "./Converter";
-import P from "bluebird";
+
 import {readFileSync} from "fs";
 import path from "path";
 import assert from "assert";

src/Result.ts

@@ -1,6 +1,6 @@
 import { Converter } from "./Converter";
 import { ProcessLineResult } from "./Processor";
-import P from "bluebird";
+
 import CSVError from "./CSVError";
 import { EOL } from "os";
 export class Result {
@@ -20,15 +20,15 @@ export class Result {
   }
   private finalResult: any[] = [];
   constructor(private converter: Converter) { }
-  processResult(resultLines: ProcessLineResult[]): P<any> {
+  processResult(resultLines: ProcessLineResult[]): Promise<any> {
     const startPos = this.converter.parseRuntime.parsedLineNumber;
     if (this.needPushDownstream && this.converter.parseParam.downstreamFormat === "array") {
       if (startPos === 0) {
         pushDownstream(this.converter, "[" + EOL);
       }
     }
-    // let prom: P<any>;
-    return new P((resolve, reject) => {
+    // let prom: Promise<any>;
+    return new Promise((resolve, reject) => {
       if (this.needEmitLine) {
         processLineByLine(
           resultLines,

v2/ProcessFork.d.ts

@@ -1,13 +1,11 @@
-/// <reference types="bluebird" />
 /// <reference types="node" />
 import { Processor, ProcessLineResult } from "./Processor";
-import P from "bluebird";
 import { Converter } from "./Converter";
 import { ChildProcess } from "child_process";
 export declare class ProcessorFork extends Processor {
     protected converter: Converter;
-    flush(): P<ProcessLineResult[]>;
-    destroy(): P<void>;
+    flush(): Promise<ProcessLineResult[]>;
+    destroy(): Promise<void>;
     childProcess: ChildProcess;
     inited: boolean;
     private resultBuf;
@@ -19,7 +17,7 @@ export declare class ProcessorFork extends Processor {
     private initWorker();
     private flushResult();
     private appendBuf(data);
-    process(chunk: Buffer): P<ProcessLineResult[]>;
+    process(chunk: Buffer): Promise<ProcessLineResult[]>;
 }
 export interface Message {
     cmd: string;