deslop-js 0.0.17 → 0.0.19-dev.42704ea

package/dist/index.cjs

@@ -35,6 +35,10 @@ let node_fs_promises = require("node:fs/promises");
 let oxc_parser = require("oxc-parser");
 let typescript = require("typescript");
 typescript = __toESM(typescript, 1);
+let node_worker_threads = require("node:worker_threads");
+let node_url = require("node:url");
+let node_os = require("node:os");
+node_os = __toESM(node_os, 1);
 let oxc_resolver = require("oxc-resolver");
 let minimatch = require("minimatch");
 
@@ -5715,7 +5719,8 @@ const FRAMEWORK_PATTERNS = [
 		alwaysUsed: [
 			"astro.config.{ts,js,mjs,cjs}",
 			"src/content/config.{js,ts,mjs,mts,cjs,cts}",
-			"src/content.config.{js,ts,mjs,mts,cjs,cts}"
+			"src/content.config.{js,ts,mjs,mts,cjs,cts}",
+			"src/live.config.{js,ts,mjs,mts,cjs,cts}"
 		]
 	},
 	{
@@ -6141,6 +6146,148 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 	};
 };
 
+//#endregion
+//#region src/utils/resolve-available-concurrency.ts
+const resolveAvailableConcurrency = () => {
+	const available = node_os.default.availableParallelism();
+	if (!Number.isFinite(available) || available < 1) return 1;
+	return Math.max(1, Math.min(Math.floor(available), 16));
+};
+
+//#endregion
+//#region src/collect/parallel-parse.ts
+const deserializeErrors = (serializedErrors) => serializedErrors.map((errorJson) => new DeslopError({
+	code: errorJson.code,
+	module: errorJson.module,
+	severity: errorJson.severity,
+	message: errorJson.message,
+	path: errorJson.path,
+	detail: errorJson.detail
+}));
+const deserializeParsedSource = (serialized) => ({
+	imports: serialized.imports,
+	exports: serialized.exports,
+	memberAccesses: serialized.memberAccesses,
+	wholeObjectUses: serialized.wholeObjectUses,
+	localIdentifierReferences: serialized.localIdentifierReferences,
+	referencedFilenames: serialized.referencedFilenames,
+	redundantTypePatterns: serialized.redundantTypePatterns,
+	identityWrappers: serialized.identityWrappers,
+	typeDefinitionHashes: serialized.typeDefinitionHashes,
+	inlineTypeLiterals: serialized.inlineTypeLiterals,
+	simplifiableFunctions: serialized.simplifiableFunctions,
+	simplifiableExpressions: serialized.simplifiableExpressions,
+	duplicateConstantCandidates: serialized.duplicateConstantCandidates,
+	errors: deserializeErrors(serialized.errors)
+});
+const resolveWorkerPath = () => {
+	const currentUrl = require("url").pathToFileURL(__filename).href;
+	if (currentUrl.endsWith(".ts")) return (0, node_url.fileURLToPath)(new URL("./parse-worker.ts", currentUrl));
+	return (0, node_url.fileURLToPath)(new URL("./parse-worker.mjs", currentUrl));
+};
+const createWorker = (workerPath) => {
+	return new node_worker_threads.Worker(workerPath, { ...workerPath.endsWith(".ts") ? { execArgv: ["--import", "tsx"] } : {} });
+};
+const waitForReady = (worker) => new Promise((resolve, reject) => {
+	const onMessage = (message) => {
+		if (message.type === "ready") {
+			worker.off("message", onMessage);
+			worker.off("error", onError);
+			resolve();
+		}
+	};
+	const onError = (error) => {
+		worker.off("message", onMessage);
+		worker.off("error", onError);
+		reject(error);
+	};
+	worker.on("message", onMessage);
+	worker.on("error", onError);
+});
+const parseFilesWithWorkerPool = async (files, workerCount) => {
+	const workerPath = resolveWorkerPath();
+	const results = new Array(files.length);
+	const workers = [];
+	try {
+		for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) workers.push(createWorker(workerPath));
+		await Promise.all(workers.map(waitForReady));
+	} catch {
+		for (const worker of workers) worker.terminate();
+		return files.map((file) => parseSourceFile(file.path));
+	}
+	let nextFileIndex = 0;
+	let completedCount = 0;
+	return new Promise((resolve, reject) => {
+		const dispatchNext = (worker) => {
+			if (nextFileIndex >= files.length) return;
+			const fileIndex = nextFileIndex;
+			nextFileIndex += 1;
+			worker.postMessage({
+				type: "parse",
+				filePath: files[fileIndex].path,
+				fileIndex
+			});
+		};
+		const onWorkerMessage = (worker) => (message) => {
+			if (message.type === "result") {
+				results[message.fileIndex] = deserializeParsedSource(message.parsed);
+				completedCount += 1;
+				if (completedCount === files.length) {
+					cleanup();
+					resolve(results);
+				} else dispatchNext(worker);
+			} else if (message.type === "error") {
+				results[message.fileIndex] = {
+					imports: [],
+					exports: [],
+					memberAccesses: [],
+					wholeObjectUses: [],
+					localIdentifierReferences: [],
+					referencedFilenames: [],
+					redundantTypePatterns: [],
+					identityWrappers: [],
+					typeDefinitionHashes: [],
+					inlineTypeLiterals: [],
+					simplifiableFunctions: [],
+					simplifiableExpressions: [],
+					duplicateConstantCandidates: [],
+					errors: [new ParseError({
+						code: "parse-failed",
+						message: `Worker parse failed: ${message.errorMessage}`,
+						path: message.filePath
+					})]
+				};
+				completedCount += 1;
+				if (completedCount === files.length) {
+					cleanup();
+					resolve(results);
+				} else dispatchNext(worker);
+			}
+		};
+		const cleanup = () => {
+			for (const worker of workers) worker.terminate();
+		};
+		for (const worker of workers) {
+			worker.on("message", onWorkerMessage(worker));
+			worker.on("error", (error) => {
+				cleanup();
+				reject(error);
+			});
+		}
+		for (const worker of workers) dispatchNext(worker);
+	});
+};
+const parseFilesInParallel = async (files) => {
+	if (files.length <= 50) return files.map((file) => parseSourceFile(file.path));
+	const concurrency = resolveAvailableConcurrency();
+	if (concurrency <= 1) return files.map((file) => parseSourceFile(file.path));
+	try {
+		return await parseFilesWithWorkerPool(files, concurrency);
+	} catch {
+		return files.map((file) => parseSourceFile(file.path));
+	}
+};
+
 //#endregion
 //#region src/utils/is-platform-builtin-or-virtual.ts
 const BUILTIN_SUBPATH_NODE_MODULES = new Set([
@@ -12590,8 +12737,23 @@ const analyze = async (config) => {
 		ignorePatterns: [...config.ignorePatterns, ...allExclusionPatterns]
 	} : config;
 	let files;
+	let discoveredEntries;
 	try {
-		files = await collectSourceFiles(configWithExclusions);
+		const [collectedFiles, resolvedEntries] = await Promise.all([collectSourceFiles(configWithExclusions), resolveEntries(configWithExclusions).catch((entriesError) => {
+			setupErrors.push(new WorkspaceError({
+				code: "workspace-discovery-failed",
+				message: "resolveEntries failed — defaulting to empty entry set",
+				path: config.rootDir,
+				detail: describeUnknownError(entriesError)
+			}));
+			return {
+				productionEntries: [],
+				testEntries: [],
+				alwaysUsedFiles: []
+			};
+		})]);
+		files = collectedFiles;
+		discoveredEntries = resolvedEntries;
 	} catch (collectError) {
 		setupErrors.push(new WorkspaceError({
 			code: "workspace-discovery-failed",
@@ -12602,22 +12764,6 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
-	let discoveredEntries;
-	try {
-		discoveredEntries = await resolveEntries(configWithExclusions);
-	} catch (entriesError) {
-		setupErrors.push(new WorkspaceError({
-			code: "workspace-discovery-failed",
-			message: "resolveEntries failed — defaulting to empty entry set",
-			path: config.rootDir,
-			detail: describeUnknownError(entriesError)
-		}));
-		discoveredEntries = {
-			productionEntries: [],
-			testEntries: [],
-			alwaysUsedFiles: []
-		};
-	}
 	const productionEntrySet = new Set(discoveredEntries.productionEntries);
 	const testEntrySet = new Set(discoveredEntries.testEntries);
 	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
@@ -12644,9 +12790,11 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
+	const parsedModules = await parseFilesInParallel(files);
 	const graphInputs = [];
-	for (const file of files) {
-		const parsedModule = parseSourceFile(file.path);
+	for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+		const file = files[fileIndex];
+		const parsedModule = parsedModules[fileIndex];
 		const resolvedImportMap = /* @__PURE__ */ new Map();
 		const safeResolveImport = (specifier) => {
 			try {

package/dist/index.mjs

@@ -4,6 +4,9 @@ import fg from "fast-glob";
 import { readFile } from "node:fs/promises";
 import { parseSync } from "oxc-parser";
 import ts from "typescript";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
 import { ResolverFactory } from "oxc-resolver";
 import { minimatch } from "minimatch";
 
@@ -5684,7 +5687,8 @@ const FRAMEWORK_PATTERNS = [
 		alwaysUsed: [
 			"astro.config.{ts,js,mjs,cjs}",
 			"src/content/config.{js,ts,mjs,mts,cjs,cts}",
-			"src/content.config.{js,ts,mjs,mts,cjs,cts}"
+			"src/content.config.{js,ts,mjs,mts,cjs,cts}",
+			"src/live.config.{js,ts,mjs,mts,cjs,cts}"
 		]
 	},
 	{
@@ -6110,6 +6114,148 @@ const discoverToolingEntryPoints = (rootDir, workspacePackages) => {
 	};
 };
 
+//#endregion
+//#region src/utils/resolve-available-concurrency.ts
+const resolveAvailableConcurrency = () => {
+	const available = os.availableParallelism();
+	if (!Number.isFinite(available) || available < 1) return 1;
+	return Math.max(1, Math.min(Math.floor(available), 16));
+};
+
+//#endregion
+//#region src/collect/parallel-parse.ts
+const deserializeErrors = (serializedErrors) => serializedErrors.map((errorJson) => new DeslopError({
+	code: errorJson.code,
+	module: errorJson.module,
+	severity: errorJson.severity,
+	message: errorJson.message,
+	path: errorJson.path,
+	detail: errorJson.detail
+}));
+const deserializeParsedSource = (serialized) => ({
+	imports: serialized.imports,
+	exports: serialized.exports,
+	memberAccesses: serialized.memberAccesses,
+	wholeObjectUses: serialized.wholeObjectUses,
+	localIdentifierReferences: serialized.localIdentifierReferences,
+	referencedFilenames: serialized.referencedFilenames,
+	redundantTypePatterns: serialized.redundantTypePatterns,
+	identityWrappers: serialized.identityWrappers,
+	typeDefinitionHashes: serialized.typeDefinitionHashes,
+	inlineTypeLiterals: serialized.inlineTypeLiterals,
+	simplifiableFunctions: serialized.simplifiableFunctions,
+	simplifiableExpressions: serialized.simplifiableExpressions,
+	duplicateConstantCandidates: serialized.duplicateConstantCandidates,
+	errors: deserializeErrors(serialized.errors)
+});
+const resolveWorkerPath = () => {
+	const currentUrl = import.meta.url;
+	if (currentUrl.endsWith(".ts")) return fileURLToPath(new URL("./parse-worker.ts", currentUrl));
+	return fileURLToPath(new URL("./parse-worker.mjs", currentUrl));
+};
+const createWorker = (workerPath) => {
+	return new Worker(workerPath, { ...workerPath.endsWith(".ts") ? { execArgv: ["--import", "tsx"] } : {} });
+};
+const waitForReady = (worker) => new Promise((resolve, reject) => {
+	const onMessage = (message) => {
+		if (message.type === "ready") {
+			worker.off("message", onMessage);
+			worker.off("error", onError);
+			resolve();
+		}
+	};
+	const onError = (error) => {
+		worker.off("message", onMessage);
+		worker.off("error", onError);
+		reject(error);
+	};
+	worker.on("message", onMessage);
+	worker.on("error", onError);
+});
+const parseFilesWithWorkerPool = async (files, workerCount) => {
+	const workerPath = resolveWorkerPath();
+	const results = new Array(files.length);
+	const workers = [];
+	try {
+		for (let workerIndex = 0; workerIndex < workerCount; workerIndex++) workers.push(createWorker(workerPath));
+		await Promise.all(workers.map(waitForReady));
+	} catch {
+		for (const worker of workers) worker.terminate();
+		return files.map((file) => parseSourceFile(file.path));
+	}
+	let nextFileIndex = 0;
+	let completedCount = 0;
+	return new Promise((resolve, reject) => {
+		const dispatchNext = (worker) => {
+			if (nextFileIndex >= files.length) return;
+			const fileIndex = nextFileIndex;
+			nextFileIndex += 1;
+			worker.postMessage({
+				type: "parse",
+				filePath: files[fileIndex].path,
+				fileIndex
+			});
+		};
+		const onWorkerMessage = (worker) => (message) => {
+			if (message.type === "result") {
+				results[message.fileIndex] = deserializeParsedSource(message.parsed);
+				completedCount += 1;
+				if (completedCount === files.length) {
+					cleanup();
+					resolve(results);
+				} else dispatchNext(worker);
+			} else if (message.type === "error") {
+				results[message.fileIndex] = {
+					imports: [],
+					exports: [],
+					memberAccesses: [],
+					wholeObjectUses: [],
+					localIdentifierReferences: [],
+					referencedFilenames: [],
+					redundantTypePatterns: [],
+					identityWrappers: [],
+					typeDefinitionHashes: [],
+					inlineTypeLiterals: [],
+					simplifiableFunctions: [],
+					simplifiableExpressions: [],
+					duplicateConstantCandidates: [],
+					errors: [new ParseError({
+						code: "parse-failed",
+						message: `Worker parse failed: ${message.errorMessage}`,
+						path: message.filePath
+					})]
+				};
+				completedCount += 1;
+				if (completedCount === files.length) {
+					cleanup();
+					resolve(results);
+				} else dispatchNext(worker);
+			}
+		};
+		const cleanup = () => {
+			for (const worker of workers) worker.terminate();
+		};
+		for (const worker of workers) {
+			worker.on("message", onWorkerMessage(worker));
+			worker.on("error", (error) => {
+				cleanup();
+				reject(error);
+			});
+		}
+		for (const worker of workers) dispatchNext(worker);
+	});
+};
+const parseFilesInParallel = async (files) => {
+	if (files.length <= 50) return files.map((file) => parseSourceFile(file.path));
+	const concurrency = resolveAvailableConcurrency();
+	if (concurrency <= 1) return files.map((file) => parseSourceFile(file.path));
+	try {
+		return await parseFilesWithWorkerPool(files, concurrency);
+	} catch {
+		return files.map((file) => parseSourceFile(file.path));
+	}
+};
+
 //#endregion
 //#region src/utils/is-platform-builtin-or-virtual.ts
 const BUILTIN_SUBPATH_NODE_MODULES = new Set([
@@ -12559,8 +12705,23 @@ const analyze = async (config) => {
 		ignorePatterns: [...config.ignorePatterns, ...allExclusionPatterns]
 	} : config;
 	let files;
+	let discoveredEntries;
 	try {
-		files = await collectSourceFiles(configWithExclusions);
+		const [collectedFiles, resolvedEntries] = await Promise.all([collectSourceFiles(configWithExclusions), resolveEntries(configWithExclusions).catch((entriesError) => {
+			setupErrors.push(new WorkspaceError({
+				code: "workspace-discovery-failed",
+				message: "resolveEntries failed — defaulting to empty entry set",
+				path: config.rootDir,
+				detail: describeUnknownError(entriesError)
+			}));
+			return {
+				productionEntries: [],
+				testEntries: [],
+				alwaysUsedFiles: []
+			};
+		})]);
+		files = collectedFiles;
+		discoveredEntries = resolvedEntries;
 	} catch (collectError) {
 		setupErrors.push(new WorkspaceError({
 			code: "workspace-discovery-failed",
@@ -12571,22 +12732,6 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
-	let discoveredEntries;
-	try {
-		discoveredEntries = await resolveEntries(configWithExclusions);
-	} catch (entriesError) {
-		setupErrors.push(new WorkspaceError({
-			code: "workspace-discovery-failed",
-			message: "resolveEntries failed — defaulting to empty entry set",
-			path: config.rootDir,
-			detail: describeUnknownError(entriesError)
-		}));
-		discoveredEntries = {
-			productionEntries: [],
-			testEntries: [],
-			alwaysUsedFiles: []
-		};
-	}
 	const productionEntrySet = new Set(discoveredEntries.productionEntries);
 	const testEntrySet = new Set(discoveredEntries.testEntries);
 	const alwaysUsedFileSet = new Set(discoveredEntries.alwaysUsedFiles);
@@ -12613,9 +12758,11 @@ const analyze = async (config) => {
 		}));
 		return buildEmptyScanResult(setupErrors, performance.now() - pipelineStartTime);
 	}
+	const parsedModules = await parseFilesInParallel(files);
 	const graphInputs = [];
-	for (const file of files) {
-		const parsedModule = parseSourceFile(file.path);
+	for (let fileIndex = 0; fileIndex < files.length; fileIndex++) {
+		const file = files[fileIndex];
+		const parsedModule = parsedModules[fileIndex];
 		const resolvedImportMap = /* @__PURE__ */ new Map();
 		const safeResolveImport = (specifier) => {
 			try {