@yutaura/csv-batch-reader 0.0.0-0 → 1.0.0

package/README.md

@@ -1 +1,39 @@
-# csv-batch-reader
+# @yutaura/csv-batch-reader
+
+## Description
+
+This is a library for reading CSV files in batch.
+
+```typescript
+import { csvBatchRead } from '@yutaura/csv-batch-reader';
+
+
+await csvBatchRead(
+  'path/to/csv-file.csv',
+  100, // batch size
+  async (headers) => {
+    // do something with headers
+  },
+  async (batch) => {
+    // do something with batch
+    for (const row of batch) {
+      // do something with row
+      console.log(row);
+    }
+  },
+);
+```
+
+## Installation
+
+```bash
+pnpm install @yutaura/csv-batch-reader
+```
+
+## License
+
+MIT
+
+## Funding
+
+If you like this library, please consider supporting me on [GitHub Sponsors](https://github.com/sponsors/YutaUra)

package/dist/csv-batch-read.d.ts

@@ -0,0 +1,2 @@
+export declare const csvBatchRead: <T extends Record<string, string> = Record<string, string>>(filePath: string, batchSize: number, handleHeader: (header: (keyof T)[]) => unknown, handleBatch: (rows: T[], batchCount: number, isLastChunk: boolean) => unknown) => Promise<void>;
+//# sourceMappingURL=csv-batch-read.d.ts.map

package/dist/csv-batch-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-batch-read.d.ts","sourceRoot":"","sources":["../src/csv-batch-read.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,GACvB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,qCAEtB,MAAM,aACL,MAAM,gBACH,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,OAAO,eACjC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,KAAK,OAAO,kBA8D9E,CAAC"}

package/dist/csv-batch-read.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=csv-batch-read.test.d.ts.map

package/dist/csv-batch-read.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-batch-read.test.d.ts","sourceRoot":"","sources":["../src/csv-batch-read.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -1,3 +1,2 @@
-export declare const x = 1;
-export declare const main: () => never;
+export { csvBatchRead } from "./csv-batch-read.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,CAAC,IAAI,CAAC;AAEnB,eAAO,MAAM,IAAI,aAEhB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,23 +17,99 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  main: () => main,
-  x: () => x
+  csvBatchRead: () => csvBatchRead
 });
 module.exports = __toCommonJS(src_exports);
-console.log("Hello World!");
-var x = 1;
-var main = () => {
-  throw new Error("This is an error");
+
+// src/csv-batch-read.ts
+var import_node_fs = require("fs");
+var import_papaparse = __toESM(require("papaparse"));
+
+// src/promise-with-resolvers.ts
+var promiseWithResolvers = () => {
+  let resolve = () => void 0;
+  let reject = () => void 0;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+};
+
+// src/csv-batch-read.ts
+var csvBatchRead = async (filePath, batchSize, handleHeader, handleBatch) => {
+  return await new Promise((resolve, reject) => {
+    const stream = (0, import_node_fs.createReadStream)(filePath).pipe(
+      import_papaparse.default.parse(import_papaparse.default.NODE_STREAM_INPUT, { header: true })
+    );
+    let buf = [];
+    let batchCount = 0;
+    let isFirstChunk = true;
+    const { promise: headerPromise, resolve: resolveHeaders } = promiseWithResolvers();
+    const headerResolved = headerPromise.then(
+      (headers) => handleHeader(headers)
+    );
+    const shouldResolve = [headerResolved];
+    stream.on("data", (chunk) => {
+      if (isFirstChunk) {
+        resolveHeaders(Object.keys(chunk));
+        isFirstChunk = false;
+      }
+      if (buf.length === batchSize) {
+        const currentBatchCount = batchCount;
+        const currentBuf = buf.slice();
+        shouldResolve.push(
+          headerResolved.then(
+            () => handleBatch(currentBuf, currentBatchCount, false)
+          )
+        );
+        buf = [];
+        batchCount++;
+      }
+      buf.push(chunk);
+    });
+    stream.on("end", () => {
+      const currentBatchCount = batchCount;
+      const currentBuf = buf.slice();
+      shouldResolve.push(
+        headerResolved.then(
+          () => handleBatch(currentBuf, currentBatchCount, true)
+        )
+      );
+      Promise.all(shouldResolve).then(() => {
+        stream.destroy();
+        resolve();
+      }).catch((error) => {
+        stream.destroy();
+        reject(error);
+      });
+    });
+    stream.on("error", (error) => {
+      console.error("error", error);
+      stream.destroy();
+      reject(error);
+    });
+  });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  main,
-  x
+  csvBatchRead
 });
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["console.log(\"Hello World!\");\n\nexport const x = 1;\n\nexport const main = () => {\n  throw new Error(\"This is an error\");\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAAQ,IAAI,cAAc;AAEnB,IAAM,IAAI;AAEV,IAAM,OAAO,MAAM;AACxB,QAAM,IAAI,MAAM,kBAAkB;AACpC;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/csv-batch-read.ts","../src/promise-with-resolvers.ts"],"sourcesContent":["export { csvBatchRead } from \"./csv-batch-read.js\";\n","import { createReadStream } from \"node:fs\";\nimport Papa from \"papaparse\";\nimport { promiseWithResolvers } from \"./promise-with-resolvers.js\";\n\nexport const csvBatchRead = async <\n  T extends Record<string, string> = Record<string, string>,\n>(\n  filePath: string,\n  batchSize: number,\n  handleHeader: (header: (keyof T)[]) => unknown,\n  handleBatch: (rows: T[], batchCount: number, isLastChunk: boolean) => unknown,\n) => {\n  return await new Promise<void>((resolve, reject) => {\n    const stream = createReadStream(filePath).pipe(\n      Papa.parse(Papa.NODE_STREAM_INPUT, { header: true }),\n    );\n\n    let buf: T[] = [];\n    let batchCount = 0;\n    let isFirstChunk = true;\n    const { promise: headerPromise, resolve: resolveHeaders } =\n      promiseWithResolvers<(keyof T)[]>();\n    const headerResolved = headerPromise.then((headers) =>\n      handleHeader(headers),\n    );\n    const shouldResolve: unknown[] = [headerResolved];\n\n    stream.on(\"data\", (chunk: T) => {\n      if (isFirstChunk) {\n        resolveHeaders(Object.keys(chunk));\n        isFirstChunk = false;\n      }\n      if (buf.length === batchSize) {\n        const currentBatchCount = batchCount;\n        const currentBuf = buf.slice();\n        shouldResolve.push(\n          headerResolved.then(() =>\n            handleBatch(currentBuf, currentBatchCount, false),\n          ),\n        );\n        buf = [];\n        batchCount++;\n      }\n      buf.push(chunk);\n    });\n\n    stream.on(\"end\", () => {\n      const currentBatchCount = batchCount;\n      const currentBuf = buf.slice();\n      shouldResolve.push(\n        headerResolved.then(() =>\n          handleBatch(currentBuf, currentBatchCount, true),\n        ),\n      );\n\n      Promise.all(shouldResolve)\n        .then(() => {\n          stream.destroy();\n          resolve();\n        })\n        .catch((error) => {\n          stream.destroy();\n          reject(error);\n        });\n    });\n\n    stream.on(\"error\", (error) => {\n      console.error(\"error\", error);\n      stream.destroy();\n      reject(error);\n    });\n  });\n};\n","export const promiseWithResolvers = <T = void>() => {\n  // new Promise のコンストラクタ自体は非同期処理を行わないため、\n  // resolve, reject への代入は promise の生成が終わったタイミングで完了している\n  let resolve: (value: T | PromiseLike<T>) => void = () => undefined;\n  let reject: (reason?: unknown) => void = () => undefined;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return {\n    promise,\n    resolve,\n    reject,\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,qBAAiC;AACjC,uBAAiB;;;ACDV,IAAM,uBAAuB,MAAgB;AAGlD,MAAI,UAA+C,MAAM;AACzD,MAAI,SAAqC,MAAM;AAC/C,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;ADVO,IAAM,eAAe,OAG1B,UACA,WACA,cACA,gBACG;AACH,SAAO,MAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAClD,UAAM,aAAS,iCAAiB,QAAQ,EAAE;AAAA,MACxC,iBAAAA,QAAK,MAAM,iBAAAA,QAAK,mBAAmB,EAAE,QAAQ,KAAK,CAAC;AAAA,IACrD;AAEA,QAAI,MAAW,CAAC;AAChB,QAAI,aAAa;AACjB,QAAI,eAAe;AACnB,UAAM,EAAE,SAAS,eAAe,SAAS,eAAe,IACtD,qBAAkC;AACpC,UAAM,iBAAiB,cAAc;AAAA,MAAK,CAAC,YACzC,aAAa,OAAO;AAAA,IACtB;AACA,UAAM,gBAA2B,CAAC,cAAc;AAEhD,WAAO,GAAG,QAAQ,CAAC,UAAa;AAC9B,UAAI,cAAc;AAChB,uBAAe,OAAO,KAAK,KAAK,CAAC;AACjC,uBAAe;AAAA,MACjB;AACA,UAAI,IAAI,WAAW,WAAW;AAC5B,cAAM,oBAAoB;AAC1B,cAAM,aAAa,IAAI,MAAM;AAC7B,sBAAc;AAAA,UACZ,eAAe;AAAA,YAAK,MAClB,YAAY,YAAY,mBAAmB,KAAK;AAAA,UAClD;AAAA,QACF;AACA,cAAM,CAAC;AACP;AAAA,MACF;AACA,UAAI,KAAK,KAAK;AAAA,IAChB,CAAC;AAED,WAAO,GAAG,OAAO,MAAM;AACrB,YAAM,oBAAoB;AAC1B,YAAM,aAAa,IAAI,MAAM;AAC7B,oBAAc;AAAA,QACZ,eAAe;AAAA,UAAK,MAClB,YAAY,YAAY,mBAAmB,IAAI;AAAA,QACjD;AAAA,MACF;AAEA,cAAQ,IAAI,aAAa,EACtB,KAAK,MAAM;AACV,eAAO,QAAQ;AACf,gBAAQ;AAAA,MACV,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,eAAO,QAAQ;AACf,eAAO,KAAK;AAAA,MACd,CAAC;AAAA,IACL,CAAC;AAED,WAAO,GAAG,SAAS,CAAC,UAAU;AAC5B,cAAQ,MAAM,SAAS,KAAK;AAC5B,aAAO,QAAQ;AACf,aAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH,CAAC;AACH;","names":["Papa"]}

package/dist/index.mjs

@@ -1,11 +1,78 @@
-// src/index.ts
-console.log("Hello World!");
-var x = 1;
-var main = () => {
-  throw new Error("This is an error");
+// src/csv-batch-read.ts
+import { createReadStream } from "node:fs";
+import Papa from "papaparse";
+
+// src/promise-with-resolvers.ts
+var promiseWithResolvers = () => {
+  let resolve = () => void 0;
+  let reject = () => void 0;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject
+  };
+};
+
+// src/csv-batch-read.ts
+var csvBatchRead = async (filePath, batchSize, handleHeader, handleBatch) => {
+  return await new Promise((resolve, reject) => {
+    const stream = createReadStream(filePath).pipe(
+      Papa.parse(Papa.NODE_STREAM_INPUT, { header: true })
+    );
+    let buf = [];
+    let batchCount = 0;
+    let isFirstChunk = true;
+    const { promise: headerPromise, resolve: resolveHeaders } = promiseWithResolvers();
+    const headerResolved = headerPromise.then(
+      (headers) => handleHeader(headers)
+    );
+    const shouldResolve = [headerResolved];
+    stream.on("data", (chunk) => {
+      if (isFirstChunk) {
+        resolveHeaders(Object.keys(chunk));
+        isFirstChunk = false;
+      }
+      if (buf.length === batchSize) {
+        const currentBatchCount = batchCount;
+        const currentBuf = buf.slice();
+        shouldResolve.push(
+          headerResolved.then(
+            () => handleBatch(currentBuf, currentBatchCount, false)
+          )
+        );
+        buf = [];
+        batchCount++;
+      }
+      buf.push(chunk);
+    });
+    stream.on("end", () => {
+      const currentBatchCount = batchCount;
+      const currentBuf = buf.slice();
+      shouldResolve.push(
+        headerResolved.then(
+          () => handleBatch(currentBuf, currentBatchCount, true)
+        )
+      );
+      Promise.all(shouldResolve).then(() => {
+        stream.destroy();
+        resolve();
+      }).catch((error) => {
+        stream.destroy();
+        reject(error);
+      });
+    });
+    stream.on("error", (error) => {
+      console.error("error", error);
+      stream.destroy();
+      reject(error);
+    });
+  });
 };
 export {
-  main,
-  x
+  csvBatchRead
 };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["console.log(\"Hello World!\");\n\nexport const x = 1;\n\nexport const main = () => {\n  throw new Error(\"This is an error\");\n};\n"],"mappings":";AAAA,QAAQ,IAAI,cAAc;AAEnB,IAAM,IAAI;AAEV,IAAM,OAAO,MAAM;AACxB,QAAM,IAAI,MAAM,kBAAkB;AACpC;","names":[]}
+{"version":3,"sources":["../src/csv-batch-read.ts","../src/promise-with-resolvers.ts"],"sourcesContent":["import { createReadStream } from \"node:fs\";\nimport Papa from \"papaparse\";\nimport { promiseWithResolvers } from \"./promise-with-resolvers.js\";\n\nexport const csvBatchRead = async <\n  T extends Record<string, string> = Record<string, string>,\n>(\n  filePath: string,\n  batchSize: number,\n  handleHeader: (header: (keyof T)[]) => unknown,\n  handleBatch: (rows: T[], batchCount: number, isLastChunk: boolean) => unknown,\n) => {\n  return await new Promise<void>((resolve, reject) => {\n    const stream = createReadStream(filePath).pipe(\n      Papa.parse(Papa.NODE_STREAM_INPUT, { header: true }),\n    );\n\n    let buf: T[] = [];\n    let batchCount = 0;\n    let isFirstChunk = true;\n    const { promise: headerPromise, resolve: resolveHeaders } =\n      promiseWithResolvers<(keyof T)[]>();\n    const headerResolved = headerPromise.then((headers) =>\n      handleHeader(headers),\n    );\n    const shouldResolve: unknown[] = [headerResolved];\n\n    stream.on(\"data\", (chunk: T) => {\n      if (isFirstChunk) {\n        resolveHeaders(Object.keys(chunk));\n        isFirstChunk = false;\n      }\n      if (buf.length === batchSize) {\n        const currentBatchCount = batchCount;\n        const currentBuf = buf.slice();\n        shouldResolve.push(\n          headerResolved.then(() =>\n            handleBatch(currentBuf, currentBatchCount, false),\n          ),\n        );\n        buf = [];\n        batchCount++;\n      }\n      buf.push(chunk);\n    });\n\n    stream.on(\"end\", () => {\n      const currentBatchCount = batchCount;\n      const currentBuf = buf.slice();\n      shouldResolve.push(\n        headerResolved.then(() =>\n          handleBatch(currentBuf, currentBatchCount, true),\n        ),\n      );\n\n      Promise.all(shouldResolve)\n        .then(() => {\n          stream.destroy();\n          resolve();\n        })\n        .catch((error) => {\n          stream.destroy();\n          reject(error);\n        });\n    });\n\n    stream.on(\"error\", (error) => {\n      console.error(\"error\", error);\n      stream.destroy();\n      reject(error);\n    });\n  });\n};\n","export const promiseWithResolvers = <T = void>() => {\n  // new Promise のコンストラクタ自体は非同期処理を行わないため、\n  // resolve, reject への代入は promise の生成が終わったタイミングで完了している\n  let resolve: (value: T | PromiseLike<T>) => void = () => undefined;\n  let reject: (reason?: unknown) => void = () => undefined;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n  return {\n    promise,\n    resolve,\n    reject,\n  };\n};\n"],"mappings":";AAAA,SAAS,wBAAwB;AACjC,OAAO,UAAU;;;ACDV,IAAM,uBAAuB,MAAgB;AAGlD,MAAI,UAA+C,MAAM;AACzD,MAAI,SAAqC,MAAM;AAC/C,QAAM,UAAU,IAAI,QAAW,CAAC,KAAK,QAAQ;AAC3C,cAAU;AACV,aAAS;AAAA,EACX,CAAC;AACD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;;;ADVO,IAAM,eAAe,OAG1B,UACA,WACA,cACA,gBACG;AACH,SAAO,MAAM,IAAI,QAAc,CAAC,SAAS,WAAW;AAClD,UAAM,SAAS,iBAAiB,QAAQ,EAAE;AAAA,MACxC,KAAK,MAAM,KAAK,mBAAmB,EAAE,QAAQ,KAAK,CAAC;AAAA,IACrD;AAEA,QAAI,MAAW,CAAC;AAChB,QAAI,aAAa;AACjB,QAAI,eAAe;AACnB,UAAM,EAAE,SAAS,eAAe,SAAS,eAAe,IACtD,qBAAkC;AACpC,UAAM,iBAAiB,cAAc;AAAA,MAAK,CAAC,YACzC,aAAa,OAAO;AAAA,IACtB;AACA,UAAM,gBAA2B,CAAC,cAAc;AAEhD,WAAO,GAAG,QAAQ,CAAC,UAAa;AAC9B,UAAI,cAAc;AAChB,uBAAe,OAAO,KAAK,KAAK,CAAC;AACjC,uBAAe;AAAA,MACjB;AACA,UAAI,IAAI,WAAW,WAAW;AAC5B,cAAM,oBAAoB;AAC1B,cAAM,aAAa,IAAI,MAAM;AAC7B,sBAAc;AAAA,UACZ,eAAe;AAAA,YAAK,MAClB,YAAY,YAAY,mBAAmB,KAAK;AAAA,UAClD;AAAA,QACF;AACA,cAAM,CAAC;AACP;AAAA,MACF;AACA,UAAI,KAAK,KAAK;AAAA,IAChB,CAAC;AAED,WAAO,GAAG,OAAO,MAAM;AACrB,YAAM,oBAAoB;AAC1B,YAAM,aAAa,IAAI,MAAM;AAC7B,oBAAc;AAAA,QACZ,eAAe;AAAA,UAAK,MAClB,YAAY,YAAY,mBAAmB,IAAI;AAAA,QACjD;AAAA,MACF;AAEA,cAAQ,IAAI,aAAa,EACtB,KAAK,MAAM;AACV,eAAO,QAAQ;AACf,gBAAQ;AAAA,MACV,CAAC,EACA,MAAM,CAAC,UAAU;AAChB,eAAO,QAAQ;AACf,eAAO,KAAK;AAAA,MACd,CAAC;AAAA,IACL,CAAC;AAED,WAAO,GAAG,SAAS,CAAC,UAAU;AAC5B,cAAQ,MAAM,SAAS,KAAK;AAC5B,aAAO,QAAQ;AACf,aAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH,CAAC;AACH;","names":[]}

package/dist/promise-with-resolvers.d.ts

@@ -0,0 +1,6 @@
+export declare const promiseWithResolvers: <T = void>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+//# sourceMappingURL=promise-with-resolvers.d.ts.map

package/dist/promise-with-resolvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-with-resolvers.d.ts","sourceRoot":"","sources":["../src/promise-with-resolvers.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,GAAI,CAAC;;qBAGf,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;sBAC1B,OAAO,KAAK,IAAI;CAUvC,CAAC"}

package/dist/promise-with-resolvers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=promise-with-resolvers.test.d.ts.map

package/dist/promise-with-resolvers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-with-resolvers.test.d.ts","sourceRoot":"","sources":["../src/promise-with-resolvers.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "@yutaura/csv-batch-reader",
-  "version": "0.0.0-0",
+  "version": "1.0.0",
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsup"
-  },
-  "exports": {
-    "types": "./dist/index.d.ts",
-    "import": "./dist/index.mjs",
-    "require": "./dist/index.js"
-  },
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "files": [
     "dist",
     "src",
@@ -22,13 +17,23 @@
   ],
   "author": "YutaUra",
   "license": "MIT",
-  "packageManager": "pnpm@9.10.0",
+  "dependencies": {
+    "papaparse": "5.4.1"
+  },
   "devDependencies": {
+    "@biomejs/biome": "1.9.2",
     "@changesets/cli": "2.27.8",
-    "@microsoft/api-extractor": "7.47.9",
     "@tsconfig/strictest": "2.0.5",
     "@types/node": "22.6.1",
+    "@types/papaparse": "5.3.14",
     "tsup": "8.3.0",
-    "typescript": "5.6.2"
+    "typescript": "5.6.2",
+    "vitest": "2.1.1"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc --noEmit && biome check --fix",
+    "test": "vitest run",
+    "publish-packages": "pnpm run build && changeset version && changeset publish"
   }
-}
+}

package/src/csv-batch-read.test.ts

@@ -0,0 +1,207 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { setTimeout } from "node:timers/promises";
+import { csvBatchRead } from "./csv-batch-read.js";
+
+const TEST_CSV_FILE = join(await mkdtemp("test-csv-file"), "test.csv");
+
+beforeAll(async () => {
+  await mkdir(dirname(TEST_CSV_FILE), { recursive: true });
+});
+
+afterAll(async () => {
+  await rm(dirname(TEST_CSV_FILE), { recursive: true });
+});
+
+beforeEach(async () => {
+  await writeFile(
+    TEST_CSV_FILE,
+    `\
+a,b,c
+100,101,102
+200,201,202
+300,301,302
+400,401,402
+500,501,502
+600,601,602
+700,701,702
+800,801,802
+900,901,902
+`,
+    { encoding: "utf-8", flag: "w" },
+  );
+});
+
+describe("csvBatchRead", () => {
+  it("should read headers", async () => {
+    // given
+    let headers: string[] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      100,
+      (h) => {
+        headers = h;
+      },
+      () => {},
+    );
+    // then
+    expect(headers).toStrictEqual(["a", "b", "c"]);
+  });
+
+  it("should read rows", async () => {
+    // given
+    const rows: Record<string, string>[][] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      3,
+      () => {},
+      (r) => {
+        rows.push(r);
+      },
+    );
+    // then
+    expect(rows).toStrictEqual([
+      [
+        { a: "100", b: "101", c: "102" },
+        { a: "200", b: "201", c: "202" },
+        { a: "300", b: "301", c: "302" },
+      ],
+      [
+        { a: "400", b: "401", c: "402" },
+        { a: "500", b: "501", c: "502" },
+        { a: "600", b: "601", c: "602" },
+      ],
+      [
+        { a: "700", b: "701", c: "702" },
+        { a: "800", b: "801", c: "802" },
+        { a: "900", b: "901", c: "902" },
+      ],
+    ]);
+  });
+
+  it("when batchSize is 1, should read rows one by one", async () => {
+    // given
+    const rows: Record<string, string>[][] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      1,
+      () => {},
+      (r) => {
+        rows.push(r);
+      },
+    );
+    // then
+    expect(rows).toStrictEqual([
+      [{ a: "100", b: "101", c: "102" }],
+      [{ a: "200", b: "201", c: "202" }],
+      [{ a: "300", b: "301", c: "302" }],
+      [{ a: "400", b: "401", c: "402" }],
+      [{ a: "500", b: "501", c: "502" }],
+      [{ a: "600", b: "601", c: "602" }],
+      [{ a: "700", b: "701", c: "702" }],
+      [{ a: "800", b: "801", c: "802" }],
+      [{ a: "900", b: "901", c: "902" }],
+    ]);
+  });
+
+  it("when batchSize is csv row count, should read rows in one batch", async () => {
+    // given
+    const rows: Record<string, string>[][] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      9,
+      () => {},
+      (r) => {
+        rows.push(r);
+      },
+    );
+    // then
+    expect(rows).toStrictEqual([
+      [
+        { a: "100", b: "101", c: "102" },
+        { a: "200", b: "201", c: "202" },
+        { a: "300", b: "301", c: "302" },
+        { a: "400", b: "401", c: "402" },
+        { a: "500", b: "501", c: "502" },
+        { a: "600", b: "601", c: "602" },
+        { a: "700", b: "701", c: "702" },
+        { a: "800", b: "801", c: "802" },
+        { a: "900", b: "901", c: "902" },
+      ],
+    ]);
+  });
+
+  it("when batchSize is larger than csv row count, should read rows in one batch", async () => {
+    // given
+    const rows: Record<string, string>[][] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      1000,
+      () => {},
+      (r) => {
+        rows.push(r);
+      },
+    );
+    // then
+    expect(rows).toStrictEqual([
+      [
+        { a: "100", b: "101", c: "102" },
+        { a: "200", b: "201", c: "202" },
+        { a: "300", b: "301", c: "302" },
+        { a: "400", b: "401", c: "402" },
+        { a: "500", b: "501", c: "502" },
+        { a: "600", b: "601", c: "602" },
+        { a: "700", b: "701", c: "702" },
+        { a: "800", b: "801", c: "802" },
+        { a: "900", b: "901", c: "902" },
+      ],
+    ]);
+  });
+
+  it("rows handler should be called after header handler", async () => {
+    // given
+    let headerResolvedAt = 0;
+    const rowsResolvedAt: number[] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      3,
+      async () => {
+        await setTimeout(500);
+        headerResolvedAt = performance.now();
+      },
+      () => {
+        rowsResolvedAt.push(performance.now());
+      },
+    );
+    // then
+    for (const rowResolvedAt of rowsResolvedAt) {
+      expect(rowResolvedAt).toBeGreaterThan(headerResolvedAt);
+    }
+  });
+
+  it("csvBatchRead should done after all rows handler resolved", async () => {
+    // given
+    const rowsResolvedAt: number[] = [];
+    // when
+    await csvBatchRead(
+      TEST_CSV_FILE,
+      3,
+      () => {},
+      async () => {
+        await setTimeout(500);
+        rowsResolvedAt.push(performance.now());
+      },
+    );
+    const csvBatchReadResolvedAt = performance.now();
+    // then
+    for (const rowResolvedAt of rowsResolvedAt) {
+      expect(rowResolvedAt).toBeLessThan(csvBatchReadResolvedAt);
+    }
+  });
+});

package/src/csv-batch-read.ts

@@ -0,0 +1,73 @@
+import { createReadStream } from "node:fs";
+import Papa from "papaparse";
+import { promiseWithResolvers } from "./promise-with-resolvers.js";
+
+export const csvBatchRead = async <
+  T extends Record<string, string> = Record<string, string>,
+>(
+  filePath: string,
+  batchSize: number,
+  handleHeader: (header: (keyof T)[]) => unknown,
+  handleBatch: (rows: T[], batchCount: number, isLastChunk: boolean) => unknown,
+) => {
+  return await new Promise<void>((resolve, reject) => {
+    const stream = createReadStream(filePath).pipe(
+      Papa.parse(Papa.NODE_STREAM_INPUT, { header: true }),
+    );
+
+    let buf: T[] = [];
+    let batchCount = 0;
+    let isFirstChunk = true;
+    const { promise: headerPromise, resolve: resolveHeaders } =
+      promiseWithResolvers<(keyof T)[]>();
+    const headerResolved = headerPromise.then((headers) =>
+      handleHeader(headers),
+    );
+    const shouldResolve: unknown[] = [headerResolved];
+
+    stream.on("data", (chunk: T) => {
+      if (isFirstChunk) {
+        resolveHeaders(Object.keys(chunk));
+        isFirstChunk = false;
+      }
+      if (buf.length === batchSize) {
+        const currentBatchCount = batchCount;
+        const currentBuf = buf.slice();
+        shouldResolve.push(
+          headerResolved.then(() =>
+            handleBatch(currentBuf, currentBatchCount, false),
+          ),
+        );
+        buf = [];
+        batchCount++;
+      }
+      buf.push(chunk);
+    });
+
+    stream.on("end", () => {
+      const currentBatchCount = batchCount;
+      const currentBuf = buf.slice();
+      shouldResolve.push(
+        headerResolved.then(() =>
+          handleBatch(currentBuf, currentBatchCount, true),
+        ),
+      );
+
+      Promise.all(shouldResolve)
+        .then(() => {
+          stream.destroy();
+          resolve();
+        })
+        .catch((error) => {
+          stream.destroy();
+          reject(error);
+        });
+    });
+
+    stream.on("error", (error) => {
+      console.error("error", error);
+      stream.destroy();
+      reject(error);
+    });
+  });
+};

package/src/index.ts

@@ -1,7 +1 @@
-console.log("Hello World!");
-
-export const x = 1;
-
-export const main = () => {
-  throw new Error("This is an error");
-};
+export { csvBatchRead } from "./csv-batch-read.js";

package/src/promise-with-resolvers.test.ts

@@ -0,0 +1,45 @@
+import { setTimeout } from "node:timers/promises";
+import { promiseWithResolvers } from "./promise-with-resolvers.js";
+
+describe("promiseWithResolvers", () => {
+  it("promiseWithResolvers returns promise, resolve, reject", () => {
+    // given
+    // when
+    const returns = promiseWithResolvers();
+    // then
+    expect(returns).toHaveProperty("promise");
+    expect(returns).toHaveProperty("resolve");
+    expect(returns).toHaveProperty("reject");
+  });
+
+  it("resolve should resolve promise", async () => {
+    // given
+    const { promise, resolve } = promiseWithResolvers<string>();
+    // when
+    resolve("resolved");
+    // then
+    await expect(promise).resolves.toBe("resolved");
+  });
+
+  it("when not resolved, promise should be pending", async () => {
+    // given
+    const { promise } = promiseWithResolvers();
+    // when
+    const res = await Promise.race([
+      promise.then(() => "resolved"),
+      setTimeout(3000).then(() => "pending"),
+    ]);
+    // then
+    // ３秒までしか待っていないけど、ずっと待ち続けることはできないので妥協
+    expect(res).toBe("pending");
+  });
+
+  it("reject should reject promise", async () => {
+    // given
+    const { promise, reject } = promiseWithResolvers();
+    // when
+    reject("rejected");
+    // then
+    await expect(promise).rejects.toBe("rejected");
+  });
+});

package/src/promise-with-resolvers.ts

@@ -0,0 +1,15 @@
+export const promiseWithResolvers = <T = void>() => {
+  // new Promise のコンストラクタ自体は非同期処理を行わないため、
+  // resolve, reject への代入は promise の生成が終わったタイミングで完了している
+  let resolve: (value: T | PromiseLike<T>) => void = () => undefined;
+  let reject: (reason?: unknown) => void = () => undefined;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve,
+    reject,
+  };
+};