@abaplint/transpiler-cli 2.10.58 → 2.10.59

package/build/bundle.js

@@ -71,6 +71,9 @@ exports.FileOperations = void 0;
 const fs = __webpack_require__(/*! fs */ "fs");
 const path = __webpack_require__(/*! path */ "path");
 const glob = __webpack_require__(/*! glob */ "./node_modules/glob/glob.js");
+const pLimit = __webpack_require__(/*! p-limit */ "./node_modules/p-limit/index.js");
+const os = __webpack_require__(/*! node:os */ "node:os");
+const fsPromises = __webpack_require__(/*! node:fs/promises */ "node:fs/promises");
 class FileOperations {
     static deleteFolderRecursive(p) {
         if (fs.existsSync(p) === false) {
@@ -78,26 +81,46 @@ class FileOperations {
         }
         fs.rmSync(p, { recursive: true });
     }
-    static loadFiles(config) {
-        const files = [];
+    static setupPLimit() {
+        let concurrency = os.cpus().length;
+        if (concurrency > 8) {
+            concurrency = 8;
+        }
+        else if (concurrency < 1) {
+            concurrency = 1;
+        }
+        return pLimit(concurrency);
+    }
+    static async readAllFiles(filesToRead, outputFolder) {
+        const limit = this.setupPLimit();
+        const promises = filesToRead.map((filename) => {
+            return limit(async () => {
+                return {
+                    filename: path.basename(filename),
+                    relative: path.relative(outputFolder, path.dirname(filename)),
+                    contents: await fsPromises.readFile(filename, "utf8"),
+                };
+            });
+        });
+        return Promise.all(promises);
+    }
+    static async loadFiles(config) {
         const filter = (config.input_filter ?? []).map(pattern => new RegExp(pattern, "i"));
         let skipped = 0;
         let added = 0;
         const folders = Array.isArray(config.input_folder) ? config.input_folder : [config.input_folder];
+        const filesToRead = [];
         for (const folder of folders) {
             for (const filename of glob.sync(folder + "/**", { nosort: true, nodir: true })) {
                 if (filter.length > 0 && filter.some(a => a.test(filename)) === false) {
                     skipped++;
                     continue;
                 }
-                files.push({
-                    filename: path.basename(filename),
-                    relative: path.relative(config.output_folder, path.dirname(filename)),
-                    contents: fs.readFileSync(filename, "utf8"),
-                });
+                filesToRead.push(filename);
                 added++;
             }
         }
+        const files = await this.readAllFiles(filesToRead, config.output_folder);
         console.log(added + " files added from source");
         console.log(skipped + " files skipped in source");
         return files;
@@ -94670,6 +94693,88 @@ function onceStrict (fn) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/p-limit/index.js":
+/*!***************************************!*\
+  !*** ./node_modules/p-limit/index.js ***!
+  \***************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+const Queue = __webpack_require__(/*! yocto-queue */ "./node_modules/yocto-queue/index.js");
+
+const pLimit = concurrency => {
+	if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
+	}
+
+	const queue = new Queue();
+	let activeCount = 0;
+
+	const next = () => {
+		activeCount--;
+
+		if (queue.size > 0) {
+			queue.dequeue()();
+		}
+	};
+
+	const run = async (fn, resolve, ...args) => {
+		activeCount++;
+
+		const result = (async () => fn(...args))();
+
+		resolve(result);
+
+		try {
+			await result;
+		} catch {}
+
+		next();
+	};
+
+	const enqueue = (fn, resolve, ...args) => {
+		queue.enqueue(run.bind(null, fn, resolve, ...args));
+
+		(async () => {
+			// This function needs to wait until the next microtask before comparing
+			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
+			// when the run function is dequeued and called. The comparison in the if-statement
+			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
+			await Promise.resolve();
+
+			if (activeCount < concurrency && queue.size > 0) {
+				queue.dequeue()();
+			}
+		})();
+	};
+
+	const generator = (fn, ...args) => new Promise(resolve => {
+		enqueue(fn, resolve, ...args);
+	});
+
+	Object.defineProperties(generator, {
+		activeCount: {
+			get: () => activeCount
+		},
+		pendingCount: {
+			get: () => queue.size
+		},
+		clearQueue: {
+			value: () => {
+				queue.clear();
+			}
+		}
+	});
+
+	return generator;
+};
+
+module.exports = pLimit;
+
+
 /***/ }),
 
 /***/ "./node_modules/path-is-absolute/index.js":
@@ -100604,6 +100709,84 @@ function wrappy (fn, cb) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/yocto-queue/index.js":
+/*!*******************************************!*\
+  !*** ./node_modules/yocto-queue/index.js ***!
+  \*******************************************/
+/***/ ((module) => {
+
+class Node {
+	/// value;
+	/// next;
+
+	constructor(value) {
+		this.value = value;
+
+		// TODO: Remove this when targeting Node.js 12.
+		this.next = undefined;
+	}
+}
+
+class Queue {
+	// TODO: Use private class fields when targeting Node.js 12.
+	// #_head;
+	// #_tail;
+	// #_size;
+
+	constructor() {
+		this.clear();
+	}
+
+	enqueue(value) {
+		const node = new Node(value);
+
+		if (this._head) {
+			this._tail.next = node;
+			this._tail = node;
+		} else {
+			this._head = node;
+			this._tail = node;
+		}
+
+		this._size++;
+	}
+
+	dequeue() {
+		const current = this._head;
+		if (!current) {
+			return;
+		}
+
+		this._head = this._head.next;
+		this._size--;
+		return current.value;
+	}
+
+	clear() {
+		this._head = undefined;
+		this._tail = undefined;
+		this._size = 0;
+	}
+
+	get size() {
+		return this._size;
+	}
+
+	* [Symbol.iterator]() {
+		let current = this._head;
+
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+}
+
+module.exports = Queue;
+
+
 /***/ }),
 
 /***/ "assert":
@@ -100661,6 +100844,28 @@ module.exports = require("fs");
 
 /***/ }),
 
+/***/ "node:fs/promises":
+/*!***********************************!*\
+  !*** external "node:fs/promises" ***!
+  \***********************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:fs/promises");
+
+/***/ }),
+
+/***/ "node:os":
+/*!**************************!*\
+  !*** external "node:os" ***!
+  \**************************/
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:os");
+
+/***/ }),
+
 /***/ "os":
 /*!*********************!*\
   !*** external "os" ***!
@@ -100861,7 +101066,7 @@ async function run() {
     console.log("Transpiler CLI");
     const config = config_1.TranspilerConfig.find(process.argv[2]);
     const libFiles = loadLib(config);
-    const files = file_operations_1.FileOperations.loadFiles(config);
+    const files = await file_operations_1.FileOperations.loadFiles(config);
     console.log("\nBuilding");
     const t = new Transpiler.Transpiler(config.options);
     const reg = new abaplint.Registry();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler-cli",
-  "version": "2.10.58",
+  "version": "2.10.59",
   "description": "Transpiler - Command Line Interface",
   "funding": "https://github.com/sponsors/larshp",
   "bin": {
@@ -28,7 +28,7 @@
   "license": "MIT",
   "devDependencies": {
     "@abaplint/core": "^2.113.125",
-    "@abaplint/transpiler": "^2.10.58",
+    "@abaplint/transpiler": "^2.10.59",
     "@types/glob": "^8.1.0",
     "@types/node": "^22.15.29",
     "@types/progress": "^2.0.7",
@@ -36,6 +36,7 @@
     "progress": "^2.0.3",
     "ts-json-schema-generator": "^2.4.0",
     "typescript": "^5.8.3",
+    "p-limit": "^3.1.0",
     "webpack-cli": "^6.0.1",
     "webpack": "^5.99.9"
   }