@wuyuchentr/file-splitter 1.0.0

package/README.md

@@ -0,0 +1,39 @@
+# @wuyuchentr/file-splitter
+
+Split large files by line count or size. **Zero dependencies, stream-based, memory-friendly.**
+
+> Read a single line at a time — works with files of any size.
+
+## Install
+
+```bash
+npm install @wuyuchentr/file-splitter
+```
+
+## Usage
+
+```js
+const { splitFile } = require('@wuyuchentr/file-splitter');
+
+// Split by lines
+const files = await splitFile('large.log', { linesPerFile: 10000 });
+// → ['large-1.log', 'large-2.log', ...]
+
+// Split by approximate size (respects line boundaries)
+const files = await splitFile('data.csv', { sizePerFile: 1024 * 1024 });
+// → ['data-1.csv', 'data-2.csv', ...]
+```
+
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `linesPerFile` | — | Max lines per output file |
+| `sizePerFile` | — | Approximate bytes per output file (boundary-safe) |
+| `outputDir` | input dir | Directory for output files |
+| `outputPrefix` | basename | Custom prefix before `-1.ext` |
+| `encoding` | `'utf-8'` | File encoding |
+
+## How it works
+
+Uses `readline` + `fs.createReadStream` under the hood. Reads one line at a time, writes to sequential output files. Memory usage stays constant regardless of file size.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@wuyuchentr/file-splitter",
+  "version": "1.0.0",
+  "description": "Split large files by line count or size. Zero-dependency, stream-based, memory-friendly.",
+  "main": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "keywords": [
+    "split",
+    "file",
+    "large-file",
+    "stream",
+    "line-split",
+    "log-splitter"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/wuyuchentr/file-splitter.git"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/src/index.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const readline = require('readline');
+const path = require('path');
+
+async function splitFile(inputFile, options = {}) {
+  const {
+    linesPerFile,
+    sizePerFile,
+    outputDir = path.dirname(inputFile),
+    outputPrefix,
+    encoding = 'utf-8',
+  } = options;
+
+  if (!linesPerFile && !sizePerFile) {
+    throw new Error('Must specify either linesPerFile or sizePerFile');
+  }
+
+  const ext = path.extname(inputFile);
+  const base = outputPrefix || path.basename(inputFile, ext);
+  const prefix = path.join(outputDir, base);
+
+  const rl = readline.createInterface({
+    input: fs.createReadStream(inputFile, { encoding }),
+    crlfDelay: Infinity,
+  });
+
+  let partNum = 1;
+  let lineCount = 0;
+  let byteCount = 0;
+  let currentStream = null;
+  const outFiles = [];
+
+  function closeCurrent() {
+    return new Promise((resolve) => {
+      if (currentStream) {
+        currentStream.end(resolve);
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  function openNext() {
+    const name = `${prefix}-${partNum}${ext}`;
+    outFiles.push(name);
+    currentStream = fs.createWriteStream(name, { encoding });
+    partNum++;
+    lineCount = 0;
+    byteCount = 0;
+  }
+
+  function shouldSplit() {
+    if (linesPerFile && lineCount >= linesPerFile) return true;
+    if (sizePerFile && lineCount > 0 && byteCount >= sizePerFile) return true;
+    return false;
+  }
+
+  openNext();
+
+  try {
+    for await (const line of rl) {
+      if (shouldSplit()) {
+        await closeCurrent();
+        openNext();
+      }
+      const lineBytes = Buffer.byteLength(line, encoding) + 1;
+      currentStream.write(line + '\n');
+      lineCount++;
+      byteCount += lineBytes;
+    }
+  } finally {
+    await closeCurrent();
+    rl.close();
+    rl.removeAllListeners();
+  }
+
+  return outFiles;
+}
+
+module.exports = { splitFile };