vite-plugin-fvtt 0.2.3 → 0.2.5

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.2.5] - 2025-09-24
+
+### Fixed
+
+- `system.json` or `module.json` in root due to missing wait condition for the check not properly copying.
+
+## [0.2.4] - 2025-09-23
+
+### Changed
+
+- Removed dependencies of `fs-extra` and `dotenv` to shrink the dependencies.
+- Async file loading should improve the performance for a large number of language files significantly.
+
 ## [0.2.3] - 2025-09-20
 
 ### Fixed

package/dist/index.d.ts

@@ -3,6 +3,6 @@ import { Plugin } from "vite";
 //#region src/index.d.ts
 declare function foundryVTTPlugin(options?: {
   buildPacks: boolean;
-}): Plugin;
+}): Promise<Plugin>;
 //#endregion
 export { foundryVTTPlugin as default };

package/dist/index.js

@@ -1,7 +1,6 @@
-import fs from "fs-extra";
 import path from "path";
-import dotenv from "dotenv";
-import { globSync } from "tinyglobby";
+import { glob } from "tinyglobby";
+import fs from "fs/promises";
 import { compilePack } from "@foundryvtt/foundryvtt-cli";
 import { Server } from "socket.io";
 import { io } from "socket.io-client";
@@ -9,17 +8,65 @@ import { io } from "socket.io-client";
 //#region src/context.ts
 const context = {};
 
+//#endregion
+//#region src/utils/fs-utils.ts
+var FsUtils = class FsUtils {
+	static async checkType(p, check) {
+		try {
+			const stats = await fs.stat(p);
+			return check(stats);
+		} catch {
+			return false;
+		}
+	}
+	static async fileExists(p) {
+		return FsUtils.checkType(p, (s) => s.isFile());
+	}
+	static async dirExists(p) {
+		return FsUtils.checkType(p, (s) => s.isDirectory());
+	}
+	static async readFile(filePath, encoding = "utf-8") {
+		return fs.readFile(filePath, { encoding });
+	}
+	static async readJson(filePath) {
+		try {
+			const content = await FsUtils.readFile(filePath);
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	}
+};
+var fs_utils_default = FsUtils;
+
 //#endregion
 //#region src/config/env.ts
-function loadEnv() {
-	const envPath = path.resolve(process.cwd(), ".env.foundryvtt.local");
-	const { parsed } = dotenv.config({
-		path: envPath,
-		quiet: true
-	});
+function parseEnv(content) {
+	const result = {};
+	for (const line of content.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const [key, ...rest] = trimmed.split("=");
+		result[key.trim()] = rest.join("=").trim();
+	}
+	return result;
+}
+async function loadEnv() {
+	const envPaths = await glob(".env.foundryvtt*", { absolute: true });
+	let merged = {
+		FOUNDRY_URL: "localhost",
+		FOUNDRY_PORT: "30000"
+	};
+	for (const file of envPaths) {
+		const content = await fs_utils_default.readFile(file, "utf-8");
+		merged = {
+			...merged,
+			...parseEnv(content)
+		};
+	}
 	return {
-		foundryUrl: parsed?.FOUNDRY_URL ?? "localhost",
-		foundryPort: parseInt(parsed?.FOUNDRY_PORT ?? "30000", 10)
+		foundryUrl: merged.FOUNDRY_URL,
+		foundryPort: parseInt(merged.FOUNDRY_PORT, 10)
 	};
 }
 
@@ -62,18 +109,20 @@ var logger_default = Logger;
 
 //#endregion
 //#region src/config/foundryvtt-manifest.ts
-function loadManifest(config) {
+async function loadManifest(config) {
 	if (context?.manifest) return context.manifest;
 	const publicDir = config.publicDir || "public";
-	const foundPath = [
+	const paths = [
 		"system.json",
 		"module.json",
 		`${publicDir}/system.json`,
 		`${publicDir}/module.json`
-	].map((relPath) => path.resolve(process.cwd(), relPath)).find((absPath) => fs.pathExistsSync(absPath));
+	].map((f) => path.resolve(process.cwd(), f));
+	const idx = (await Promise.all(paths.map((p) => fs_utils_default.fileExists(p)))).findIndex(Boolean);
+	const foundPath = idx !== -1 ? paths[idx] : void 0;
 	if (!foundPath) logger_default.fail(`Could not find a manifest file (system.json or module.json) in project root or ${publicDir}/.`);
 	try {
-		const data = fs.readJsonSync(foundPath);
+		const data = await fs_utils_default.readJson(foundPath);
 		if (!data.id || typeof data.id !== "string") logger_default.fail(`Manifest at ${foundPath} is missing required "id" field.`);
 		const hasEsmodules = Array.isArray(data.esmodules) && data.esmodules.length > 0;
 		const hasScripts = Array.isArray(data.scripts) && data.scripts.length > 0;
@@ -247,26 +296,28 @@ var PathUtils = class PathUtils {
 		}
 		return PathUtils._root;
 	}
-	static getOutDirFile(p) {
+	static async getOutDirFile(p) {
 		const file = path.join(PathUtils.getOutDir(), p);
-		return fs.existsSync(file) ? file : "";
+		return await fs_utils_default.fileExists(file) ? file : "";
 	}
-	static getPublicDirFile(p) {
+	static async getPublicDirFile(p) {
 		const file = path.join(PathUtils.getPublicDir(), p);
-		return fs.existsSync(file) ? file : "";
+		return await fs_utils_default.fileExists(file) ? file : "";
 	}
-	static findLocalFilePath(p) {
-		return [
+	static async findLocalFilePath(p) {
+		const fileCandidates = [
 			PathUtils.getPublicDir(),
 			PathUtils.getSourceDirectory(),
 			PathUtils.getRoot()
-		].map((pth) => path.join(pth, p)).find((pth) => fs.existsSync(pth)) ?? null;
+		].map((pth) => path.join(pth, p));
+		const idx = (await Promise.all(fileCandidates.map(fs_utils_default.fileExists))).findIndex(Boolean);
+		return idx !== -1 ? fileCandidates[idx] : null;
 	}
 	static isFoundryVTTUrl(p) {
 		const decodedBase = PathUtils.getDecodedBase();
 		return path.posix.normalize(p).startsWith(decodedBase);
 	}
-	static foundryVTTUrlToLocal(p) {
+	static async foundryVTTUrlToLocal(p) {
 		const decodedBase = PathUtils.getDecodedBase();
 		let pathToTransform = path.posix.normalize("/" + p);
 		if (!pathToTransform.startsWith(decodedBase)) return null;
@@ -295,29 +346,33 @@ var path_utils_default = PathUtils;
 
 //#endregion
 //#region src/language/loader.ts
-function getLocalLanguageFiles(lang, outDir = false) {
+async function getLocalLanguageFiles(lang, outDir = false) {
 	const language = context.manifest.languages.find((l) => l.lang === lang);
 	if (!language) logger_default.fail(`Cannot find language "${lang}"`);
 	const langPath = language?.path ?? "";
-	if (outDir) return [path_utils_default.getOutDirFile(langPath)];
-	const publicDirFile = path_utils_default.getPublicDirFile(langPath);
+	if (outDir) return [await path_utils_default.getOutDirFile(langPath)];
+	const publicDirFile = await path_utils_default.getPublicDirFile(langPath);
 	if (publicDirFile !== "") return [publicDirFile];
 	const sourcePath = path_utils_default.getLanguageSourcePath(langPath, lang);
-	if (!fs.existsSync(sourcePath) || !fs.statSync(sourcePath).isDirectory()) {
-		logger_default.warn(`No language folder found at: ${sourcePath}`);
-		return [];
-	}
-	return globSync(path.join(sourcePath, "**/*.json"), { absolute: true });
+	if (await fs_utils_default.dirExists(sourcePath)) return await glob(path.join(sourcePath, "**/*.json"), { absolute: true });
+	logger_default.warn(`No language folder found at: ${sourcePath}`);
+	return [];
 }
-function loadLanguage(lang, outDir = false) {
-	const files = getLocalLanguageFiles(lang, outDir);
+async function loadLanguage(lang, outDir = false) {
+	const files = await getLocalLanguageFiles(lang, outDir);
 	const result = /* @__PURE__ */ new Map();
-	for (const file of files) try {
-		result.set(file, fs.readJSONSync(file));
-		languageTracker.addFile(lang, file);
-	} catch (e) {
-		logger_default.warn(e);
-	}
+	const reads = files.map(async (file) => {
+		try {
+			const json = await fs_utils_default.readJson(file);
+			languageTracker.addFile(lang, file);
+			return [file, json];
+		} catch (e) {
+			logger_default.warn(e);
+			return null;
+		}
+	});
+	const results = await Promise.all(reads);
+	for (const entry of results) if (entry) result.set(entry[0], entry[1]);
 	return result;
 }
 
@@ -356,9 +411,9 @@ function transform(dataMap) {
 
 //#endregion
 //#region src/language/validator.ts
-function validator() {
+async function validator() {
 	const manifest = context.manifest;
-	const baseLanguageData = loadLanguage("en", true);
+	const baseLanguageData = await loadLanguage("en", true);
 	if (baseLanguageData.size === 0) {
 		logger_default.error("Base language \"en\" not found or could not be loaded.");
 		return;
@@ -366,7 +421,7 @@ function validator() {
 	const base = flattenKeys(baseLanguageData.values().next().value);
 	for (const lang of manifest.languages) {
 		if (lang.lang === "en") continue;
-		const currentLanguageData = loadLanguage(lang.lang, true);
+		const currentLanguageData = await loadLanguage(lang.lang, true);
 		if (currentLanguageData.size === 0) {
 			logger_default.warn(`Summary for language [${lang.lang}]: Could not be loaded.`);
 			continue;
@@ -388,15 +443,19 @@ async function compileManifestPacks() {
 	for (const pack of context.manifest.packs) {
 		const srcCandidates = [path.resolve(path_utils_default.getSourceDirectory(), pack.path), path.resolve(path_utils_default.getRoot(), pack.path)];
 		const dest = path.resolve(path_utils_default.getOutDir(), pack.path);
-		const chosenSrc = srcCandidates.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isDirectory());
+		let chosenSrc;
+		for (const candidate of srcCandidates) if (await fs_utils_default.dirExists(candidate)) {
+			chosenSrc = candidate;
+			break;
+		}
 		if (!chosenSrc) {
 			logger_default.warn(`Pack path not found for ${pack.path}, skipped.`);
 			continue;
 		}
-		const hasYaml = fs.readdirSync(chosenSrc, {
-			recursive: true,
-			encoding: "utf8"
-		}).some((entry) => entry.endsWith(".yaml") || entry.endsWith(".yml"));
+		const hasYaml = (await glob(["**/*.yaml", "**/*.yml"], {
+			cwd: chosenSrc,
+			absolute: true
+		})).length > 0;
 		await compilePack(chosenSrc, dest, {
 			yaml: hasYaml,
 			recursive: true
@@ -421,7 +480,7 @@ const handlebarsTracker = new HandlebarsTracker();
 //#endregion
 //#region src/server/http-middleware.ts
 function httpMiddlewareHook(server) {
-	server.middlewares.use((req, res, next) => {
+	server.middlewares.use(async (req, res, next) => {
 		const config = context.config;
 		if (!path_utils_default.isFoundryVTTUrl(req.url ?? "")) {
 			next();
@@ -438,7 +497,7 @@ function httpMiddlewareHook(server) {
 		const languages = context.manifest.languages.filter((lang) => path_utils_default.localToFoundryVTTUrl(lang.path) === path.posix.normalize(req.url ?? ""));
 		if (languages.length === 1) {
 			const lang = languages[0].lang;
-			const language = loadLanguage(lang);
+			const language = await loadLanguage(lang);
 			const jsonData = transform(language);
 			res.setHeader("Content-Type", "application/json");
 			res.end(JSON.stringify(jsonData, null, 2));
@@ -458,13 +517,14 @@ function socketProxy(server) {
 			upgrade: false,
 			query: socket.handshake.query
 		});
-		socket.onAny((event, ...args) => {
+		socket.onAny(async (event, ...args) => {
 			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
 			if (event === "template") {
-				const localPath = path_utils_default.foundryVTTUrlToLocal(args[0]);
+				const localPath = await path_utils_default.foundryVTTUrlToLocal(args[0]);
 				if (localPath) {
+					const html = await fs_utils_default.readFile(localPath);
 					if (maybeAck) maybeAck({
-						html: fs.readFileSync(localPath, "utf8"),
+						html,
 						success: true
 					});
 					handlebarsTracker.addFile(args[0], localPath);
@@ -574,24 +634,23 @@ if (import.meta.hot) {
 
 //#endregion
 //#region src/index.ts
-function foundryVTTPlugin(options = { buildPacks: true }) {
-	context.env = loadEnv();
+async function foundryVTTPlugin(options = { buildPacks: true }) {
+	context.env = await loadEnv();
 	return {
 		name: "vite-plugin-fvtt",
-		config(config) {
-			context.manifest = loadManifest(config) ?? void 0;
+		async config(config) {
+			context.manifest = await loadManifest(config) ?? void 0;
 			return createPartialViteConfig(config);
 		},
 		configResolved(config) {
 			context.config = config;
 		},
 		async generateBundle() {
-			const manifestCandidates = ["system.json", "module.json"];
-			for (const file of manifestCandidates) {
+			for (const file of ["system.json", "module.json"]) {
 				const src = path.resolve(file);
-				if (!path_utils_default.getPublicDirFile(file) && fs.existsSync(src)) {
+				if (!await path_utils_default.getPublicDirFile(file) && await fs_utils_default.fileExists(src)) {
 					this.addWatchFile(src);
-					const manifest = fs.readJsonSync(src);
+					const manifest = await fs_utils_default.readJson(src);
 					this.emitFile({
 						type: "asset",
 						fileName: file,
@@ -601,9 +660,11 @@ function foundryVTTPlugin(options = { buildPacks: true }) {
 			}
 			const languages = context.manifest?.languages ?? [];
 			if (languages.length > 0) for (const language of languages) {
-				if (path_utils_default.getPublicDirFile(language.path)) continue;
-				getLocalLanguageFiles(language.lang).forEach((langFile) => this.addWatchFile(langFile));
-				const languageDataRaw = loadLanguage(language.lang);
+				if (await path_utils_default.getPublicDirFile(language.path)) continue;
+				getLocalLanguageFiles(language.lang).then((langFiles) => {
+					langFiles.forEach((file) => this.addWatchFile(file));
+				});
+				const languageDataRaw = await loadLanguage(language.lang);
 				const languageData = transform(languageDataRaw);
 				this.emitFile({
 					type: "asset",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-fvtt",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "A Vite plugin for module and system development for Foundry VTT",
   "keywords": [
     "vite",
@@ -33,7 +33,6 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",
-    "@types/fs-extra": "^11.0.4",
     "@types/node": "^24.3.0",
     "eslint": "^9.34.0",
     "prettier": "^3.6.2",
@@ -45,8 +44,6 @@
   },
   "dependencies": {
     "@foundryvtt/foundryvtt-cli": "^3.0.0",
-    "dotenv": "^17.2.1",
-    "fs-extra": "^11.3.1",
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
     "tinyglobby": "^0.2.15"