@adonisjs/assembler 8.0.0-next.3 → 8.0.0-next.30

package/build/virtual_file_system-bGeoWsK-.js

@@ -0,0 +1,285 @@
+import { copyFile, mkdir, readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import string from "@poppinss/utils/string";
+import { relative } from "node:path/posix";
+import Cache from "tmp-cache";
+import { isJunk } from "junk";
+import fastGlob from "fast-glob";
+import Hooks from "@poppinss/hooks";
+import { existsSync } from "node:fs";
+import getRandomPort from "get-port";
+import { execa, execaNode } from "execa";
+import { importDefault, naturalSort } from "@poppinss/utils";
+import { EnvLoader, EnvParser } from "@adonisjs/env";
+import chokidar from "chokidar";
+import { parseTsconfig } from "get-tsconfig";
+import { basename, dirname as dirname$1, isAbsolute, join as join$1, relative as relative$1 } from "node:path";
+import { debuglog } from "node:util";
+import { fdir } from "fdir";
+import lodash from "@poppinss/utils/lodash";
+import { Lang, parse } from "@ast-grep/napi";
+import picomatch from "picomatch";
+var debug_default = debuglog("adonisjs:assembler");
+const DEFAULT_NODE_ARGS = ["--import=@poppinss/ts-exec", "--enable-source-maps"];
+function parseConfig(cwd, ts) {
+	const cwdPath = typeof cwd === "string" ? cwd : fileURLToPath(cwd);
+	const configFile = join$1(cwdPath, "tsconfig.json");
+	debug_default("parsing config file \"%s\"", configFile);
+	let hardException = null;
+	const parsedConfig = ts.getParsedCommandLineOfConfigFile(configFile, {}, {
+		...ts.sys,
+		useCaseSensitiveFileNames: true,
+		getCurrentDirectory: () => cwdPath,
+		onUnRecoverableConfigFileDiagnostic: (error) => hardException = error
+	});
+	if (hardException) {
+		const compilerHost = ts.createCompilerHost({});
+		console.log(ts.formatDiagnosticsWithColorAndContext([hardException], compilerHost));
+		return;
+	}
+	if (parsedConfig.errors.length) {
+		const compilerHost = ts.createCompilerHost({});
+		console.log(ts.formatDiagnosticsWithColorAndContext(parsedConfig.errors, compilerHost));
+		return;
+	}
+	if (parsedConfig.raw.include) parsedConfig.raw.include = parsedConfig.raw.include.map((includePath) => {
+		return includePath.replace("${configDir}/", "");
+	});
+	if (parsedConfig.raw.exclude) parsedConfig.raw.exclude = parsedConfig.raw.exclude.map((excludePath) => {
+		return excludePath.replace("${configDir}/", "");
+	});
+	return parsedConfig;
+}
+function readTsConfig(cwd) {
+	const tsConfigPath = join$1(cwd, "tsconfig.json");
+	debug_default("reading config file from location \"%s\"", tsConfigPath);
+	try {
+		const tsConfig = parseTsconfig(tsConfigPath);
+		if (tsConfig.include) tsConfig.include = tsConfig.include.map((resolvedPath) => {
+			return resolvedPath.replace(cwd, "");
+		});
+		if (tsConfig.exclude) tsConfig.exclude = tsConfig.exclude.map((resolvedPath) => {
+			return resolvedPath.replace(cwd, "");
+		});
+		debug_default("read tsconfig %O", tsConfig);
+		return {
+			path: tsConfigPath,
+			config: tsConfig
+		};
+	} catch {
+		return null;
+	}
+}
+function runNode(cwd, options) {
+	return execaNode(options.script, options.scriptArgs, {
+		nodeOptions: DEFAULT_NODE_ARGS.concat(options.nodeArgs),
+		preferLocal: true,
+		windowsHide: false,
+		localDir: cwd,
+		cwd,
+		reject: options.reject ?? false,
+		buffer: false,
+		stdio: options.stdio || "inherit",
+		env: {
+			...options.stdio === "pipe" ? { FORCE_COLOR: "true" } : {},
+			...options.env
+		}
+	});
+}
+function run(cwd, options) {
+	return execa(options.script, options.scriptArgs, {
+		preferLocal: true,
+		windowsHide: false,
+		localDir: cwd,
+		cwd,
+		buffer: false,
+		stdio: options.stdio || "inherit",
+		env: {
+			...options.stdio === "pipe" ? { FORCE_COLOR: "true" } : {},
+			...options.env
+		}
+	});
+}
+function watch(options) {
+	return chokidar.watch(["."], options);
+}
+async function getPort(cwd) {
+	if (process.env.PORT) return getRandomPort({ port: Number(process.env.PORT) });
+	const files = await new EnvLoader(cwd).load();
+	for (let file of files) {
+		const envVariables = await new EnvParser(file.contents, cwd).parse();
+		if (envVariables.PORT) return getRandomPort({ port: Number(envVariables.PORT) });
+	}
+	return getRandomPort({ port: 3333 });
+}
+async function copyFiles(files, cwd, outDir) {
+	const { paths, patterns } = files.reduce((result, file) => {
+		if (fastGlob.isDynamicPattern(file)) {
+			result.patterns.push(file);
+			return result;
+		}
+		if (existsSync(join$1(cwd, file))) result.paths.push(file);
+		return result;
+	}, {
+		patterns: [],
+		paths: []
+	});
+	debug_default("copyFiles inputs: %O, paths: %O, patterns: %O", files, paths, patterns);
+	const filePaths = paths.concat(await fastGlob(patterns, {
+		cwd,
+		dot: true
+	})).filter((file) => {
+		return !isJunk(basename(file));
+	});
+	debug_default("copying files %O to destination \"%s\"", filePaths, outDir);
+	const copyPromises = filePaths.map(async (file) => {
+		const src = isAbsolute(file) ? file : join$1(cwd, file);
+		const dest = join$1(outDir, relative$1(cwd, src));
+		await mkdir(dirname$1(dest), { recursive: true });
+		return copyFile(src, dest);
+	});
+	return await Promise.all(copyPromises);
+}
+function memoize(fn, maxKeys) {
+	const cache = new Cache({ max: maxKeys });
+	return (input, ...args) => {
+		if (cache.has(input)) return cache.get(input);
+		return fn(input, ...args);
+	};
+}
+function isRelative(pathValue) {
+	return pathValue.startsWith("./") || pathValue.startsWith("../");
+}
+async function loadHooks(rcFileHooks, names) {
+	const groups = names.map((name) => {
+		return {
+			group: name,
+			hooks: rcFileHooks?.[name] ?? []
+		};
+	});
+	const hooks = new Hooks();
+	for (const { group, hooks: collection } of groups) for (const item of collection) if ("run" in item) hooks.add(group, item.run);
+	else hooks.add(group, await importDefault(item));
+	return hooks;
+}
+function throttle(fn, name) {
+	name = name || "throttled";
+	let isBusy = false;
+	let hasQueuedCalls = false;
+	let lastCallArgs;
+	async function throttled(...args) {
+		if (isBusy) {
+			debug_default("ignoring \"%s\" invocation as current execution is in progress", name);
+			hasQueuedCalls = true;
+			lastCallArgs = args;
+			return;
+		}
+		isBusy = true;
+		debug_default("executing throttled function \"%s\"", name);
+		await fn(...args);
+		debug_default("executed throttled function \"%s\"", name);
+		isBusy = false;
+		if (hasQueuedCalls) {
+			hasQueuedCalls = false;
+			debug_default("resuming and running latest \"%s\" invocation", name);
+			await throttled(...lastCallArgs);
+		}
+	}
+	return throttled;
+}
+function removeExtension(filePath) {
+	return filePath.substring(0, filePath.lastIndexOf("."));
+}
+const BYPASS_FN = (input) => input;
+const DEFAULT_GLOB = [
+	"**/!(*.d).ts",
+	"**/*.tsx",
+	"**/*.js"
+];
+var VirtualFileSystem = class {
+	#source;
+	#options;
+	#files = /* @__PURE__ */ new Map();
+	#astCache = new Cache({ max: 60 });
+	#matcher;
+	#picoMatchOptions;
+	constructor(source, options) {
+		this.#source = source;
+		this.#options = options ?? {};
+		this.#picoMatchOptions = { cwd: this.#source };
+		this.#matcher = picomatch(this.#options.glob ?? DEFAULT_GLOB, this.#picoMatchOptions);
+	}
+	async scan() {
+		debug_default("fetching entities from source \"%s\"", this.#source);
+		const crawler = new fdir().globWithOptions(this.#options.glob ?? DEFAULT_GLOB, this.#picoMatchOptions).withFullPaths();
+		if (this.#options.filter) crawler.filter(this.#options.filter);
+		const filesList = await crawler.crawl(this.#source).withPromise();
+		debug_default("scanned files %O", filesList);
+		const sortedFiles = filesList.sort(naturalSort);
+		this.#files.clear();
+		for (let filePath of sortedFiles) {
+			filePath = string.toUnixSlash(filePath);
+			const relativePath = removeExtension(relative(this.#source, filePath));
+			this.#files.set(filePath, relativePath);
+		}
+	}
+	has(filePath) {
+		if (this.#files.has(filePath)) return true;
+		if (!filePath.startsWith(this.#source)) return false;
+		return this.#matcher(filePath);
+	}
+	asList(options) {
+		const list = {};
+		const transformKey = options?.transformKey ?? BYPASS_FN;
+		const transformValue = options?.transformValue ?? BYPASS_FN;
+		for (const [filePath, relativePath] of this.#files) list[transformKey(relativePath)] = transformValue(filePath);
+		return list;
+	}
+	asTree(options) {
+		const list = {};
+		const transformKey = options?.transformKey ?? BYPASS_FN;
+		const transformValue = options?.transformValue ?? BYPASS_FN;
+		for (const [filePath, relativePath] of this.#files) {
+			const key = transformKey(relativePath);
+			lodash.set(list, key.split("/"), transformValue(filePath, key));
+		}
+		return list;
+	}
+	add(filePath) {
+		if (this.has(filePath)) {
+			debug_default("adding new \"%s\" file to the virtual file system", filePath);
+			const relativePath = removeExtension(relative(this.#source, filePath));
+			this.#files.set(filePath, relativePath);
+			return true;
+		}
+		return false;
+	}
+	remove(filePath) {
+		debug_default("removing \"%s\" file from virtual file system", filePath);
+		return this.#files.delete(filePath);
+	}
+	async get(filePath) {
+		const cached = this.#astCache.get(filePath);
+		if (cached) {
+			debug_default("returning AST nodes from cache \"%s\"", filePath);
+			return cached;
+		}
+		const fileContents = await readFile(filePath, "utf-8");
+		debug_default("parsing \"%s\" file to AST", filePath);
+		this.#astCache.set(filePath, parse(Lang.TypeScript, fileContents).root());
+		return this.#astCache.get(filePath);
+	}
+	invalidate(filePath) {
+		if (filePath) {
+			debug_default("invalidate AST cache \"%s\"", filePath);
+			this.#astCache.delete(filePath);
+		} else {
+			debug_default("clear AST cache");
+			this.#astCache.clear();
+		}
+	}
+	clear() {
+		this.#files.clear();
+	}
+};
+export { loadHooks as a, readTsConfig as c, runNode as d, throttle as f, isRelative as i, removeExtension as l, debug_default as m, copyFiles as n, memoize as o, watch as p, getPort as r, parseConfig as s, VirtualFileSystem as t, run as u };

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@adonisjs/assembler",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
-  "version": "8.0.0-next.3",
+  "version": "8.0.0-next.30",
   "engines": {
     "node": ">=24.0.0"
   },
-  "imports": {
-    "#tests/*": "./tests/*.ts"
-  },
   "main": "build/index.js",
   "type": "module",
   "files": [
@@ -19,6 +16,8 @@
     ".": "./build/index.js",
     "./code_transformer": "./build/src/code_transformer/main.js",
     "./routes_scanner": "./build/src/code_scanners/routes_scanner/main.js",
+    "./index_generator": "./build/src/index_generator/main.js",
+    "./helpers": "./build/src/helpers.js",
     "./types": "./build/src/types/main.js"
   },
   "scripts": {
@@ -29,56 +28,61 @@
     "clean": "del-cli build",
     "typecheck": "tsc --noEmit",
     "precompile": "npm run lint && npm run clean",
-    "compile": "tsup-node && tsc --emitDeclarationOnly --declaration",
+    "compile": "tsdown && tsc --emitDeclarationOnly --declaration",
     "build": "npm run compile",
+    "docs": "typedoc",
     "release": "release-it",
     "version": "npm run build",
     "prepublishOnly": "npm run build",
-    "quick:test": "cross-env NODE_DEBUG=adonisjs:assembler node --enable-source-maps --import=@poppinss/ts-exec --experimental-import-meta-resolve bin/test.ts"
+    "quick:test": "cross-env NODE_DEBUG=adonisjs:assembler node --enable-source-maps --import=@poppinss/ts-exec bin/test.ts"
   },
   "devDependencies": {
-    "@adonisjs/eslint-config": "^3.0.0-next.0",
+    "@adonisjs/eslint-config": "^3.0.0-next.9",
     "@adonisjs/prettier-config": "^1.4.5",
-    "@adonisjs/tsconfig": "^2.0.0-next.0",
-    "@japa/assert": "^4.1.1",
-    "@japa/file-system": "^2.3.2",
-    "@japa/runner": "^4.4.0",
-    "@japa/snapshot": "^2.0.9",
+    "@adonisjs/tsconfig": "^2.0.0-next.3",
+    "@japa/assert": "^4.2.0",
+    "@japa/file-system": "^3.0.0",
+    "@japa/runner": "^5.0.0",
+    "@japa/snapshot": "^2.0.10",
     "@poppinss/ts-exec": "^1.4.1",
-    "@release-it/conventional-changelog": "^10.0.1",
-    "@types/node": "^24.3.0",
+    "@release-it/conventional-changelog": "^10.0.4",
+    "@types/node": "^25.0.5",
     "@types/picomatch": "^4.0.2",
     "@types/pretty-hrtime": "^1.0.3",
     "c8": "^10.1.3",
-    "cross-env": "^10.0.0",
-    "del-cli": "^6.0.0",
-    "eslint": "^9.34.0",
-    "hot-hook": "^0.4.1-next.0",
-    "p-event": "^6.0.1",
-    "prettier": "^3.6.2",
-    "release-it": "^19.0.4",
-    "tsup": "^8.5.0",
-    "typescript": "^5.9.2"
+    "cross-env": "^10.1.0",
+    "del-cli": "^7.0.0",
+    "eslint": "^9.39.2",
+    "hot-hook": "^0.4.1-next.2",
+    "p-event": "^7.0.2",
+    "prettier": "^3.7.4",
+    "release-it": "^19.2.3",
+    "tsdown": "^0.19.0",
+    "typedoc": "^0.28.15",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@adonisjs/env": "^6.2.0",
+    "@adonisjs/env": "^7.0.0-next.3",
     "@antfu/install-pkg": "^1.1.0",
-    "@ast-grep/napi": "^0.39.4",
-    "@poppinss/cliui": "^6.4.4",
-    "@poppinss/hooks": "^7.2.6",
-    "@poppinss/utils": "^7.0.0-next.3",
-    "chokidar": "^4.0.3",
-    "dedent": "^1.6.0",
-    "execa": "^9.6.0",
+    "@ast-grep/napi": "^0.40.4",
+    "@poppinss/cliui": "^6.6.0",
+    "@poppinss/hooks": "^7.3.0",
+    "@poppinss/utils": "^7.0.0-next.5",
+    "chokidar": "^5.0.0",
+    "dedent": "^1.7.1",
+    "execa": "^9.6.1",
     "fast-glob": "^3.3.3",
+    "fdir": "^6.5.0",
     "get-port": "^7.1.0",
+    "get-tsconfig": "^4.13.0",
+    "import-meta-resolve": "^4.2.0",
     "junk": "^4.0.1",
-    "open": "^10.2.0",
-    "parse-imports": "^2.2.1",
+    "open": "^11.0.0",
+    "parse-imports": "^3.0.0",
     "picomatch": "^4.0.3",
     "pretty-hrtime": "^1.0.3",
     "tmp-cache": "^1.1.0",
-    "ts-morph": "^26.0.0"
+    "ts-morph": "^27.0.2"
   },
   "peerDependencies": {
     "typescript": "^4.0.0 || ^5.0.0"
@@ -101,17 +105,23 @@
   "publishConfig": {
     "provenance": true
   },
-  "tsup": {
+  "tsdown": {
     "entry": [
       "./index.ts",
       "./src/types/main.ts",
+      "./src/helpers.ts",
+      "./src/code_scanners/routes_scanner/main.ts",
+      "./src/index_generator/main.ts",
       "./src/code_transformer/main.ts"
     ],
     "outDir": "./build",
     "clean": true,
     "format": "esm",
+    "minify": "dce-only",
+    "fixedExtension": false,
     "dts": false,
-    "sourcemap": false,
+    "treeshake": false,
+    "sourcemaps": false,
     "target": "esnext"
   },
   "release-it": {

package/build/chunk-RR4HCA4M.js

@@ -1,7 +0,0 @@
-// src/debug.ts
-import { debuglog } from "util";
-var debug_default = debuglog("adonisjs:assembler");
-
-export {
-  debug_default
-};

package/build/src/ast_file_system.d.ts

@@ -1,17 +0,0 @@
-import { type SgNode } from '@ast-grep/napi';
-/**
- * An abstraction around converting files to an AST and caching
- * them forever. The cache could be cleared manually.
- */
-export declare class AstFileSystem {
-    #private;
-    /**
-     * Returns the file contents as AST-grep node and caches it
-     * forever.
-     */
-    get(filePath: string): Promise<SgNode>;
-    /**
-     * Clear AST cache for a single file or all the files
-     */
-    clear(filePath?: string): void;
-}