skipRow added.

Author: cemayan

README.md

@@ -13,8 +13,8 @@ npm install --save async-chunk-reader
 
 ## Changelog
 > Added reading from zip file (v1.0.6) 
-
-> Feature to be added :  Reading via url (v1.0.7)
+> Added skipRows (v.1.0.8)
+> to be added in the future (v.1.0.9)
 
 ## API
 ---
@@ -134,5 +134,54 @@ main();
 ```
 
 
+### specialChunkSize : 
+
+```javascript
+async function main(){
+
+    const data = await reader
+        .init({
+            chunkSize: 100000,
+            inputFile: 'example/Archive.zip',
+            specialChunkSize : {0:10000, 1:40000}
+        })
+        .get()
+
+    for await(let chunk of  data){
+        console.log(chunk.map(d=>d.value))
+    }
+}
+
+main();
+
+```
+
+
+
+
+
+### to be added in the future (v.1.0.9)
+### skipRows : 
+
+```javascript
+async function main(){
+
+    const data = await reader
+        .init({
+            chunkSize: 100000,
+            inputFile: 'example/Archive.zip',
+            skipRows : 40000
+        })
+        .get()
+
+    for await(let chunk of  data){
+        console.log(chunk.map(d=>d.value))
+    }
+}
+
+main();
+
+```
+
 
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "async-chunk-reader",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Async chunk reader",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package.json

@@ -6,13 +6,16 @@ import { Stream, Readable } from "stream";
 import events from "events";
 import yauzl from "yauzl";
 
-const gunzip = zlib.createGunzip();
+
+
 
 export interface InitParameters{
     chunkSize : number,
     encoding? : string,
     inputFile : String|Stream,
-    selectedFileName? :String
+    selectedFileName? :String,
+    specialChunkSize?:{[key: number]: number },
+    skipRows? : number
 }
 
 export interface ReaderParameters{
@@ -39,9 +42,11 @@ interface IterableInterface {
      next(): Promise<IteratorResult<object>>;
 }
 
+
 events.EventEmitter.defaultMaxListeners = 1000;
+//let chunkCounter = 0 ;
 
-export  function init(parameters : InitParameters =  {chunkSize : 10000, encoding : "utf8", inputFile: "", selectedFileName: ""}) {
+export  function init(parameters : InitParameters =  {chunkSize : 10000, encoding : "utf8", inputFile: "", selectedFileName: "", specialChunkSize: {}, skipRows: 0}) {
 
     return {async get(){
 
@@ -50,8 +55,9 @@ export  function init(parameters : InitParameters =  {chunkSize : 10000, encodin
 
         if(typeof(parameters.inputFile) == "string"){
             if(path.extname(<string>parameters.inputFile)==".gz"){
+                const gunzip = zlib.createGunzip()
                 fileStream = fs.createReadStream(<string>parameters.inputFile).pipe(gunzip);
-            } 
+           } 
             else if(path.extname(<string>parameters.inputFile)==".zip"){
 
                 zipFileStream =  new Promise((resolve,reject) => {
@@ -84,7 +90,12 @@ export  function init(parameters : InitParameters =  {chunkSize : 10000, encodin
                 input: typeof(zipFileStream) === "undefined" ?  fileStream : await zipFileStream,
             });
 
-            let async_itr = rl[Symbol.asyncIterator]();               
+            let async_itr:AsyncIterableIterator<{}> = rl[Symbol.asyncIterator]();   
+            
+            if(parameters.hasOwnProperty("skipRows")) {
+                async_itr = skipRow(parameters,async_itr);
+            }
+
             return  readLineByStream(parameters,async_itr); 
         }  
         else if(parameters.inputFile instanceof Stream ){
@@ -137,14 +148,63 @@ async function  readMoreData(parameters:InitParameters ,asyncIterator :AsyncIter
     let count = 0;
     let arr:Array<object> = [];
 
+
     while(count < parameters.chunkSize){
         const resolved_obj  =  await asyncIterator.next();
         if(!resolved_obj.done){
             arr.push(resolved_obj);
         }
         count++;
     }
+
+
     return  arr;
 }
 
 
+
+
+// async function  readMoreData(parameters:InitParameters ,asyncIterator :AsyncIterableIterator<object>):Promise<Array<object>>{
+
+//     let count = 0;
+//     let arr:Array<object> = [];
+
+//     let currentChunkSize = 0 ;
+//     if(parameters.hasOwnProperty("specialChunkSize") &&  parameters.specialChunkSize![0] !== 0 ) {
+//         currentChunkSize = parameters.specialChunkSize![chunkCounter]
+//     }
+//     else {
+//         currentChunkSize = parameters.chunkSize
+//     }
+
+
+//     while(count < currentChunkSize){
+//         const resolved_obj  =  await asyncIterator.next();
+//         if(!resolved_obj.done){
+//             arr.push(resolved_obj);
+//         }
+//         count++;
+//     }
+
+  
+//     if(parameters.hasOwnProperty("specialChunkSize")){
+//         chunkCounter++;
+//     }
+
+//     return  arr;
+// }
+
+
+
+
+function skipRow(parameters:InitParameters ,asyncIterator :AsyncIterableIterator<{}>) {
+
+    let count = 0;
+    
+    while(count <  parameters.skipRows!){
+       asyncIterator.next();
+       count++;
+    }
+
+    return asyncIterator;
+}