vite-plugin-fvtt 0.2.5 → 0.2.6

package/CHANGELOG.md

@@ -1,17 +1,40 @@
 # Changelog
 
+[0.2.6] - 2025-10-01
+
+### Added
+
+- CI now tests against Node.js Latest, 20 LTS, and 22 LTS, ensuring Foundry projects compile across
+  supported environments.
+- Badges were added to the README for improved project visibility.
+- Dependabot now tracks GitHub Actions, not just NPM dependencies.
+
+### Changed
+
+- HMR logic updated to mirror Foundry V14's internal implementation, with a full fallback to V13
+  behavior for templates and JSON language files. _(If Foundry doesn't end up relying on the new
+  data shape in V14, this will have been an over-engineered no-op; but future-proofing beats
+  regret.)_
+- ESLint configuration significantly tightened:
+  - Added sonarjs and unicorn plugins for deeper static analysis.
+  - Upgraded TypeScript ESLint rules from recommended to strict, increasing development signal
+    accuracy.
+- Test suite refactored to reduce duplication and simplify onboarding for future test additions.
+
 ## [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.
+- `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.
+- Async file loading should improve the performance for a large number of language files
+  significantly.
 
 ## [0.2.3] - 2025-09-20
 
@@ -101,7 +124,10 @@
 
 - Initial Release
 
-[unreleased]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.3...HEAD
+[unreleased]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.6...HEAD
+[0.2.6]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.5...v0.2.6
+[0.2.5]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.4...v0.2.5
+[0.2.4]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.3...v0.2.4
 [0.2.3]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.2...v0.2.3
 [0.2.2]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.1...v0.2.2
 [0.2.1]: https://github.com/MatyeusM/vite-plugin-fvtt/compare/v0.2.0...v0.2.1

package/README.md

@@ -1,4 +1,14 @@
-# **vite-plugin-fvtt**
+<h1 align="center">vite-plugin-fvtt</h1>
+
+<div align="center">
+
+![NPM Version](https://img.shields.io/npm/v/vite-plugin-fvtt?style=for-the-badge&labelColor=1a1c23&color=a9cbae)
+![GitHub License](https://img.shields.io/github/license/MatyeusM/vite-plugin-fvtt?style=for-the-badge&labelColor=1a1c23&color=97cdcc)
+![GitHub last commit](https://img.shields.io/github/last-commit/MatyeusM/vite-plugin-fvtt?style=for-the-badge&labelColor=1a1c23&color=a1c6e1)
+![GitHub repo size](https://img.shields.io/github/repo-size/MatyeusM/vite-plugin-fvtt?style=for-the-badge&labelColor=1a1c23&color=bdbde4)
+![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/MatyeusM/vite-plugin-fvtt/ci.yml?style=for-the-badge&labelColor=1a1c23&color=d6b5d2)
+
+</div>
 
 A [Vite](https://vitejs.dev/) plugin to **streamline and automate** the development of Foundry VTT
 modules and systems.
@@ -45,7 +55,7 @@ export default defineConfig({
 
 ## **⚙️ Features**
 
-### **1. Configuration**
+### **1. Configuration (Optional)**
 
 The plugin needs to know where your Foundry VTT instance is running to proxy and serve assets
 correctly. If you want to change anything from the defaults `http://localhost:30000`, create a

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,6 +1,6 @@
-import path from "path";
+import path from "node:path";
 import { glob } from "tinyglobby";
-import fs from "fs/promises";
+import fs from "node:fs/promises";
 import { compilePack } from "@foundryvtt/foundryvtt-cli";
 import { Server } from "socket.io";
 import { io } from "socket.io-client";
@@ -9,39 +9,36 @@ import { io } from "socket.io-client";
 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 });
+//#region src/utils/fs-utilities.ts
+async function checkType(p, check) {
+	try {
+		const stats = await fs.stat(p);
+		return check(stats);
+	} catch {
+		return false;
 	}
-	static async readJson(filePath) {
-		try {
-			const content = await FsUtils.readFile(filePath);
-			return JSON.parse(content);
-		} catch {
-			return null;
-		}
+}
+async function fileExists(p) {
+	return checkType(p, (s) => s.isFile());
+}
+async function directoryExists(p) {
+	return checkType(p, (s) => s.isDirectory());
+}
+async function readFile(filePath, encoding = "utf8") {
+	return fs.readFile(filePath, { encoding });
+}
+async function readJson(filePath) {
+	try {
+		const content = await readFile(filePath);
+		return JSON.parse(content);
+	} catch {
+		return;
 	}
-};
-var fs_utils_default = FsUtils;
+}
 
 //#endregion
-//#region src/config/env.ts
-function parseEnv(content) {
+//#region src/config/environment.ts
+function parseEnvironment(content) {
 	const result = {};
 	for (const line of content.split(/\r?\n/)) {
 		const trimmed = line.trim();
@@ -51,93 +48,105 @@ function parseEnv(content) {
 	}
 	return result;
 }
-async function loadEnv() {
-	const envPaths = await glob(".env.foundryvtt*", { absolute: true });
+async function loadEnvironment() {
+	const environmentPaths = 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");
+	for (const file of environmentPaths) {
+		const content = await readFile(file);
 		merged = {
 			...merged,
-			...parseEnv(content)
+			...parseEnvironment(content)
 		};
 	}
 	return {
 		foundryUrl: merged.FOUNDRY_URL,
-		foundryPort: parseInt(merged.FOUNDRY_PORT, 10)
+		foundryPort: Number.parseInt(merged.FOUNDRY_PORT, 10)
 	};
 }
 
 //#endregion
 //#region src/utils/logger.ts
-var Logger = class Logger {
-	static namespace = "vite-plugin-fvtt";
-	static colors = {
-		info: "\x1B[36m",
-		warn: "\x1B[33m",
-		error: "\x1B[31m"
-	};
-	static reset = "\x1B[0m";
-	initialize(namespace = "vite-plugin-fvtt") {
-		Logger.namespace = namespace;
-	}
-	static format(level, message) {
-		return `${Logger.colors[level] ?? ""}[${Logger.namespace}] [${level.toUpperCase()}]${Logger.reset} ${message}`;
-	}
-	static info(message) {
-		console.log(Logger.format("info", message));
-	}
-	static warn(message) {
-		console.warn(Logger.format("warn", message));
-	}
-	static error(message) {
-		console.error(Logger.format("error", message));
-	}
-	static fail(message) {
-		const formatted = Logger.format("error", Logger.stringify(message));
-		console.error(formatted);
-		throw new Error(formatted);
-	}
-	static stringify(message) {
-		if (message instanceof Error) return message.stack ?? message.message;
-		return typeof message === "string" ? message : JSON.stringify(message, null, 2);
-	}
+let loggerNamespace = "vite-plugin-fvtt";
+const colors = {
+	info: "\x1B[36m",
+	warn: "\x1B[33m",
+	error: "\x1B[31m"
 };
-var logger_default = Logger;
+const reset = "\x1B[0m";
+function format(level, message) {
+	return `${colors[level] ?? ""}[${loggerNamespace}] [${level.toUpperCase()}]${reset} ${message}`;
+}
+function info(message) {
+	console.log(format("info", message));
+}
+function warn(message) {
+	console.warn(format("warn", message));
+}
+function error(message) {
+	console.error(format("error", message));
+}
+function fail(message) {
+	const formatted = format("error", stringify(message));
+	console.error(formatted);
+	throw new Error(formatted);
+}
+function stringify(message) {
+	if (message instanceof Error) return message.stack ?? message.message;
+	return typeof message === "string" ? message : JSON.stringify(message, void 0, 2);
+}
 
 //#endregion
 //#region src/config/foundryvtt-manifest.ts
-async function loadManifest(config) {
-	if (context?.manifest) return context.manifest;
-	const publicDir = config.publicDir || "public";
+async function resolveManifestPath(publicDirectory) {
 	const paths = [
 		"system.json",
 		"module.json",
-		`${publicDir}/system.json`,
-		`${publicDir}/module.json`
+		`${publicDirectory}/system.json`,
+		`${publicDirectory}/module.json`
 	].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}/.`);
+	const index = (await Promise.all(paths.map((p) => fileExists(p)))).findIndex(Boolean);
+	return index === -1 ? void 0 : paths[index];
+}
+function isLanguageEntry(object) {
+	return typeof object === "object" && object !== null && "lang" in object && "path" in object && typeof object.lang === "string" && typeof object.path === "string";
+}
+function isPackEntry(object) {
+	return typeof object === "object" && object !== null && "path" in object && typeof object.path === "string";
+}
+function validateManifest(rawData, foundPath) {
+	if (typeof rawData !== "object" || rawData === null) fail(`Manifest at ${foundPath} is not a valid JSON object.`);
+	const data = rawData;
+	if (typeof data.id !== "string") fail("Manifest is missing required \"id\" field or it is not a string");
+	const esmodules = Array.isArray(data.esmodules) ? data.esmodules.map(String) : [];
+	const scripts = Array.isArray(data.scripts) ? data.scripts.map(String) : [];
+	if (esmodules.length > 0 === scripts.length > 0) fail("Manifest must define exactly one of \"esmodules\" or \"scripts\"");
+	const styles = Array.isArray(data.styles) ? data.styles.map(String) : [];
+	const languages = Array.isArray(data.languages) && data.languages.every((entry) => isLanguageEntry(entry)) ? data.languages : [];
+	const packs = Array.isArray(data.packs) && data.packs.every((entry) => isPackEntry(entry)) ? data.packs : [];
+	return {
+		manifestType: foundPath.includes("module.json") ? "module" : "system",
+		id: data.id,
+		esmodules,
+		scripts,
+		styles,
+		languages,
+		packs
+	};
+}
+async function loadManifest(config) {
+	if (context?.manifest) return context.manifest;
+	const publicDirectory = config.publicDir || "public";
+	const foundPath = await resolveManifestPath(publicDirectory);
+	if (!foundPath) fail(`Could not find a manifest file (system.json or module.json) in project root or ${publicDirectory}/.`);
 	try {
-		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;
-		if (hasEsmodules === hasScripts) logger_default.fail(`Manifest at ${foundPath} must define exactly one of "esmodules" or "scripts".`);
-		return {
-			manifestType: foundPath.includes("module.json") ? "module" : "system",
-			id: data.id,
-			esmodules: Array.isArray(data.esmodules) ? data.esmodules : [],
-			scripts: Array.isArray(data.scripts) ? data.scripts : [],
-			styles: Array.isArray(data.styles) ? data.styles : [],
-			languages: Array.isArray(data.languages) ? data.languages : [],
-			packs: Array.isArray(data.packs) ? data.packs : []
-		};
-	} catch (err) {
-		logger_default.fail(`Failed to read manifest at ${foundPath}: ${err?.message || err}`);
+		const rawData = await readJson(foundPath);
+		return validateManifest(rawData, foundPath);
+	} catch (error$1) {
+		if (error$1 instanceof Error) fail(`Failed to read manifest at ${foundPath}: ${error$1.message}`);
+		fail(`Failed to read manifest at ${foundPath}: ${String(error$1)}`);
 	}
 }
 
@@ -148,15 +157,17 @@ function createPartialViteConfig(config) {
 	const useEsModules = context.manifest?.esmodules.length === 1;
 	const formats = useEsModules ? ["es"] : ["umd"];
 	const fileName = (useEsModules ? context.manifest?.esmodules[0] : context.manifest?.scripts?.[0]) ?? "scripts/bundle.js";
-	if (!(useEsModules || context.manifest?.scripts?.[0])) logger_default.warn("No output file specified in manifest, using default \"bundle\" in the \"scripts/\" folder");
-	if (!context.manifest?.styles?.length) logger_default.warn("No CSS file found in manifest");
+	if (!(useEsModules || context.manifest?.scripts?.[0])) warn("No output file specified in manifest, using default \"bundle\" in the \"scripts/\" folder");
+	if (!context.manifest?.styles?.length) warn("No CSS file found in manifest");
 	const cssFileName = context.manifest?.styles[0] ?? "styles/bundle.css";
-	if (!context.manifest?.styles[0]) logger_default.warn("No output css file specified in manifest, using default \"bundle\" in the \"styles/\" folder");
+	if (!context.manifest?.styles[0]) warn("No output css file specified in manifest, using default \"bundle\" in the \"styles/\" folder");
 	const foundryPort = context.env?.foundryPort ?? 3e4;
 	const foundryUrl = context.env?.foundryUrl ?? "localhost";
-	const entry = (config.build?.lib)?.entry;
-	if (!entry) logger_default.fail("Entry must be specified in lib");
-	if (typeof entry !== "string") logger_default.fail("Only a singular string entry is supported for build.lib.entry");
+	const library = config.build?.lib;
+	if (!library || typeof library !== "object") fail("This plugin needs a configured build.lib");
+	const entry = library.entry;
+	if (!entry) fail("Entry must be specified in lib");
+	if (typeof entry !== "string") fail("Only a singular string entry is supported for build.lib.entry");
 	const isWatch = process.argv.includes("--watch") || !!config.build?.watch;
 	return {
 		base,
@@ -199,7 +210,7 @@ function createPartialViteConfig(config) {
 var AbstractFileTracker = class {
 	initialized = false;
 	tracked = /* @__PURE__ */ new Map();
-	watcher = null;
+	watcher = void 0;
 	config;
 	constructor(config) {
 		this.config = config;
@@ -211,7 +222,7 @@ var AbstractFileTracker = class {
 		this.watcher.on("change", (changedPath) => {
 			const value = this.tracked.get(changedPath);
 			if (!value) return;
-			logger_default.info(`Attempting to hot reload ${changedPath}`);
+			info(`Attempting to hot reload ${changedPath}`);
 			const eventData = this.getEventData(changedPath, value);
 			server.ws.send({
 				type: "custom",
@@ -243,132 +254,128 @@ var LanguageTracker = class extends AbstractFileTracker {
 const languageTracker = new LanguageTracker();
 
 //#endregion
-//#region src/utils/path-utils.ts
-var PathUtils = class PathUtils {
-	static _config = null;
-	static _sourceDirectory = null;
-	static _decodedBase = null;
-	static _publicDir = null;
-	static _outDir = null;
-	static _root = null;
-	static getConfig() {
-		if (!PathUtils._config) {
-			const config = context.config;
-			if (!config) logger_default.fail("Path utils can only be called after vite has resolved the config");
-			PathUtils._config = config;
-		}
-		return PathUtils._config;
-	}
-	static getDecodedBase() {
-		if (!PathUtils._decodedBase) {
-			const config = PathUtils.getConfig();
-			PathUtils._decodedBase = path.posix.normalize(decodeURI(config.base));
-		}
-		return PathUtils._decodedBase;
-	}
-	static getSourceDirectory() {
-		if (!PathUtils._sourceDirectory) {
-			const config = PathUtils.getConfig();
-			const segments = path.normalize(config.build.lib.entry.toString()).split(path.sep).filter(Boolean).filter((s) => s !== ".");
-			const firstFolder = segments.length > 0 ? segments[0] : ".";
-			PathUtils._sourceDirectory = path.join(config.root, firstFolder);
-		}
-		return PathUtils._sourceDirectory;
-	}
-	static getPublicDir() {
-		if (!PathUtils._publicDir) {
-			const config = PathUtils.getConfig();
-			PathUtils._publicDir = path.resolve(config.publicDir);
-		}
-		return PathUtils._publicDir;
-	}
-	static getOutDir() {
-		if (!PathUtils._outDir) {
-			const config = PathUtils.getConfig();
-			PathUtils._outDir = path.resolve(config.build.outDir);
-		}
-		return PathUtils._outDir;
-	}
-	static getRoot() {
-		if (!PathUtils._root) {
-			const config = PathUtils.getConfig();
-			PathUtils._root = path.resolve(config.root);
-		}
-		return PathUtils._root;
-	}
-	static async getOutDirFile(p) {
-		const file = path.join(PathUtils.getOutDir(), p);
-		return await fs_utils_default.fileExists(file) ? file : "";
-	}
-	static async getPublicDirFile(p) {
-		const file = path.join(PathUtils.getPublicDir(), p);
-		return await fs_utils_default.fileExists(file) ? file : "";
-	}
-	static async findLocalFilePath(p) {
-		const fileCandidates = [
-			PathUtils.getPublicDir(),
-			PathUtils.getSourceDirectory(),
-			PathUtils.getRoot()
-		].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;
+//#region src/utils/path-utilities.ts
+let _config;
+let _sourceDirectory;
+let _decodedBase;
+let _publicDirectory;
+let _outDirectory;
+let _root;
+function getConfig() {
+	if (!_config) {
+		const config = context.config;
+		if (!config) fail("Path utils can only be called after vite has resolved the config");
+		_config = config;
 	}
-	static isFoundryVTTUrl(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		return path.posix.normalize(p).startsWith(decodedBase);
+	return _config;
+}
+function getDecodedBase() {
+	if (!_decodedBase) {
+		const config = getConfig();
+		_decodedBase = path.posix.normalize(decodeURI(config.base));
 	}
-	static async foundryVTTUrlToLocal(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		let pathToTransform = path.posix.normalize("/" + p);
-		if (!pathToTransform.startsWith(decodedBase)) return null;
-		pathToTransform = path.relative(decodedBase, pathToTransform);
-		return PathUtils.findLocalFilePath(pathToTransform);
+	return _decodedBase;
+}
+function getSourceDirectory() {
+	if (!_sourceDirectory) {
+		const config = getConfig();
+		const segments = path.normalize(config.build.lib.entry.toString()).split(path.sep).filter(Boolean).filter((s) => s !== ".");
+		const firstFolder = segments.length > 0 ? segments[0] : ".";
+		_sourceDirectory = path.join(config.root, firstFolder);
+	}
+	return _sourceDirectory;
+}
+function getPublicDirectory() {
+	if (!_publicDirectory) {
+		const config = getConfig();
+		_publicDirectory = path.resolve(config.publicDir);
 	}
-	static localToFoundryVTTUrl(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		let pathToTransform = path.normalize(p);
-		[
-			PathUtils.getPublicDir(),
-			PathUtils.getSourceDirectory(),
-			PathUtils.getRoot()
-		].forEach((pth) => {
-			if (pathToTransform.startsWith(pth)) pathToTransform = pathToTransform.slice(pth.length);
-		});
-		return path.join(decodedBase, pathToTransform);
+	return _publicDirectory;
+}
+function getOutDirectory() {
+	if (!_outDirectory) {
+		const config = getConfig();
+		_outDirectory = path.resolve(config.build.outDir);
 	}
-	static getLanguageSourcePath(p, lang) {
-		const dir = path.parse(p).dir;
-		const finalSegments = path.basename(dir) === lang ? dir : path.join(dir, lang);
-		return path.join(PathUtils.getSourceDirectory(), finalSegments);
+	return _outDirectory;
+}
+function getRoot() {
+	if (!_root) {
+		const config = getConfig();
+		_root = path.resolve(config.root);
 	}
-};
-var path_utils_default = PathUtils;
+	return _root;
+}
+async function getOutDirectoryFile(p) {
+	const file = path.join(getOutDirectory(), p);
+	return await fileExists(file) ? file : "";
+}
+async function getPublicDirectoryFile(p) {
+	const file = path.join(getPublicDirectory(), p);
+	return await fileExists(file) ? file : "";
+}
+async function findLocalFilePath(p) {
+	const fileCandidates = [
+		getPublicDirectory(),
+		getSourceDirectory(),
+		getRoot()
+	].map((pth) => path.join(pth, p));
+	const index = (await Promise.all(fileCandidates.map((file) => fileExists(file)))).findIndex(Boolean);
+	return index === -1 ? void 0 : fileCandidates[index];
+}
+function isFoundryVTTUrl(p) {
+	const decodedBase = getDecodedBase();
+	return path.posix.normalize(p).startsWith(decodedBase);
+}
+async function foundryVTTUrlToLocal(p) {
+	const decodedBase = getDecodedBase();
+	let pathToTransform = path.posix.normalize("/" + p);
+	if (!pathToTransform.startsWith(decodedBase)) return void 0;
+	pathToTransform = path.relative(decodedBase, pathToTransform);
+	return findLocalFilePath(pathToTransform);
+}
+function localToFoundryVTTUrl(p) {
+	const decodedBase = getDecodedBase();
+	let pathToTransform = path.normalize(p);
+	for (const pth of [
+		getPublicDirectory(),
+		getSourceDirectory(),
+		getRoot()
+	]) if (pathToTransform.startsWith(pth)) pathToTransform = pathToTransform.slice(pth.length);
+	return path.join(decodedBase, pathToTransform);
+}
+function getLanguageSourcePath(p, lang) {
+	const directory = path.parse(p).dir;
+	const finalSegments = path.basename(directory) === lang ? directory : path.join(directory, lang);
+	return path.join(getSourceDirectory(), finalSegments);
+}
 
 //#endregion
 //#region src/language/loader.ts
-async function getLocalLanguageFiles(lang, outDir = false) {
+async function getLocalLanguageFiles(lang, inOutDirectory = false) {
 	const language = context.manifest.languages.find((l) => l.lang === lang);
-	if (!language) logger_default.fail(`Cannot find language "${lang}"`);
+	if (!language) fail(`Cannot find language "${lang}"`);
 	const langPath = language?.path ?? "";
-	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 (await fs_utils_default.dirExists(sourcePath)) return await glob(path.join(sourcePath, "**/*.json"), { absolute: true });
-	logger_default.warn(`No language folder found at: ${sourcePath}`);
+	if (inOutDirectory) return [await getOutDirectoryFile(langPath)];
+	const publicDirectoryFile = await getPublicDirectoryFile(langPath);
+	if (publicDirectoryFile !== "") return [publicDirectoryFile];
+	const sourcePath = getLanguageSourcePath(langPath, lang);
+	if (await directoryExists(sourcePath)) return await glob(path.join(sourcePath, "**/*.json"), { absolute: true });
+	warn(`No language folder found at: ${sourcePath}`);
 	return [];
 }
-async function loadLanguage(lang, outDir = false) {
-	const files = await getLocalLanguageFiles(lang, outDir);
+async function loadLanguage(lang, inOutDirectory = false) {
+	const files = await getLocalLanguageFiles(lang, inOutDirectory);
 	const result = /* @__PURE__ */ new Map();
 	const reads = files.map(async (file) => {
 		try {
-			const json = await fs_utils_default.readJson(file);
+			const json = await readJson(file);
+			if (typeof json !== "object" || json === null) throw new Error(`Language file ${file} is not a valid JSON object`);
 			languageTracker.addFile(lang, file);
 			return [file, json];
-		} catch (e) {
-			logger_default.warn(e);
-			return null;
+		} catch (error$1) {
+			warn(error$1);
+			return;
 		}
 	});
 	const results = await Promise.all(reads);
@@ -378,17 +385,17 @@ async function loadLanguage(lang, outDir = false) {
 
 //#endregion
 //#region src/language/transformer.ts
-function flattenKeys(obj, prefix = "") {
+function flattenKeys(object, prefix = "") {
 	const result = {};
-	for (const [key, val] of Object.entries(obj)) {
+	for (const [key, value] of Object.entries(object)) {
 		const fullKey = prefix ? `${prefix}.${key}` : key;
-		if (val && typeof val === "object" && !Array.isArray(val)) Object.assign(result, flattenKeys(val, fullKey));
-		else result[fullKey] = val;
+		if (value && typeof value === "object" && !Array.isArray(value)) Object.assign(result, flattenKeys(value, fullKey));
+		else result[fullKey] = value;
 	}
 	return result;
 }
 function expandDotNotationKeys(target, source, depth = 0) {
-	if (depth > 32) logger_default.fail("Max object expansion depth exceeded.");
+	if (depth > 32) fail("Max object expansion depth exceeded.");
 	if (!source || typeof source !== "object" || Array.isArray(source)) return source;
 	for (const [key, value] of Object.entries(source)) {
 		let current = target;
@@ -411,28 +418,39 @@ function transform(dataMap) {
 
 //#endregion
 //#region src/language/validator.ts
+function getFirstMapValueOrWarn(map, contextDescription) {
+	if (map.size === 0) {
+		warn(`${contextDescription} is empty.`);
+		return;
+	}
+	const first = map.values().next().value;
+	if (!first) {
+		warn(`${contextDescription} has no valid data.`);
+		return;
+	}
+	return first;
+}
 async function validator() {
 	const manifest = context.manifest;
 	const baseLanguageData = await loadLanguage("en", true);
-	if (baseLanguageData.size === 0) {
-		logger_default.error("Base language \"en\" not found or could not be loaded.");
+	const base = getFirstMapValueOrWarn(baseLanguageData, "Base language \"en\"");
+	if (!base) {
+		error("Base language \"en\" not found or could not be loaded.");
 		return;
 	}
-	const base = flattenKeys(baseLanguageData.values().next().value);
+	const baseFlattened = flattenKeys(base);
 	for (const lang of manifest.languages) {
 		if (lang.lang === "en") continue;
 		const currentLanguageData = await loadLanguage(lang.lang, true);
-		if (currentLanguageData.size === 0) {
-			logger_default.warn(`Summary for language [${lang.lang}]: Could not be loaded.`);
-			continue;
-		}
-		const current = flattenKeys(currentLanguageData.values().next().value);
-		const missing = Object.keys(base).filter((key) => !(key in current));
-		const extra = Object.keys(current).filter((key) => !(key in base));
-		logger_default.info(`Summary for language [${lang.lang}]:`);
-		if (missing.length) console.warn(`Missing keys: ${missing.length}`, missing.slice(0, 5));
-		if (extra.length) console.warn(`Extra keys: ${extra.length}`, extra.slice(0, 5));
-		if (!missing.length && !extra.length) console.log("	✅ All keys match.");
+		const current = getFirstMapValueOrWarn(currentLanguageData, `Language "${lang.lang}"`);
+		if (!current) continue;
+		const currentFlattened = flattenKeys(current);
+		const missing = Object.keys(baseFlattened).filter((key) => !(key in currentFlattened));
+		const extra = Object.keys(currentFlattened).filter((key) => !(key in baseFlattened));
+		info(`Summary for language [${lang.lang}]:`);
+		if (missing.length > 0) console.warn(`Missing keys: ${missing.length}`, missing.slice(0, 5));
+		if (extra.length > 0) console.warn(`Extra keys: ${extra.length}`, extra.slice(0, 5));
+		if (missing.length === 0 && extra.length === 0) console.log("	✅ All keys match.");
 	}
 }
 
@@ -441,26 +459,26 @@ async function validator() {
 async function compileManifestPacks() {
 	if (!context.manifest?.packs) return;
 	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);
-		let chosenSrc;
-		for (const candidate of srcCandidates) if (await fs_utils_default.dirExists(candidate)) {
-			chosenSrc = candidate;
+		const sourceCandidates = [path.resolve(getSourceDirectory(), pack.path), path.resolve(getRoot(), pack.path)];
+		const destination = path.resolve(getOutDirectory(), pack.path);
+		let chosenSource;
+		for (const candidate of sourceCandidates) if (await directoryExists(candidate)) {
+			chosenSource = candidate;
 			break;
 		}
-		if (!chosenSrc) {
-			logger_default.warn(`Pack path not found for ${pack.path}, skipped.`);
+		if (!chosenSource) {
+			warn(`Pack path not found for ${pack.path}, skipped.`);
 			continue;
 		}
 		const hasYaml = (await glob(["**/*.yaml", "**/*.yml"], {
-			cwd: chosenSrc,
+			cwd: chosenSource,
 			absolute: true
 		})).length > 0;
-		await compilePack(chosenSrc, dest, {
+		await compilePack(chosenSource, destination, {
 			yaml: hasYaml,
 			recursive: true
 		});
-		logger_default.info(`Compiled pack ${pack.path} (${hasYaml ? "YAML" : "JSON"}) from ${chosenSrc}`);
+		info(`Compiled pack ${pack.path} (${hasYaml ? "YAML" : "JSON"}) from ${chosenSource}`);
 	}
 }
 
@@ -480,27 +498,27 @@ const handlebarsTracker = new HandlebarsTracker();
 //#endregion
 //#region src/server/http-middleware.ts
 function httpMiddlewareHook(server) {
-	server.middlewares.use(async (req, res, next) => {
+	server.middlewares.use(async (request, response, next) => {
 		const config = context.config;
-		if (!path_utils_default.isFoundryVTTUrl(req.url ?? "")) {
+		if (!isFoundryVTTUrl(request.url ?? "")) {
 			next();
 			return;
 		}
 		const cssFileName = config.build.lib.cssFileName;
-		const cssEntry = cssFileName ? path_utils_default.localToFoundryVTTUrl(`${cssFileName}.css`) : null;
-		if (path.posix.normalize(req.url ?? "") === cssEntry) {
-			logger_default.info(`Blocking CSS entry to ${req.url}`);
-			res.setHeader("Content-Type", "text/css");
-			res.end("/* The cake is in another castle. */");
+		const cssEntry = cssFileName ? localToFoundryVTTUrl(`${cssFileName}.css`) : void 0;
+		if (path.posix.normalize(request.url ?? "") === cssEntry) {
+			info(`Blocking CSS entry to ${request.url}`);
+			response.setHeader("Content-Type", "text/css");
+			response.end("/* The cake is in another castle. */");
 			return;
 		}
-		const languages = context.manifest.languages.filter((lang) => path_utils_default.localToFoundryVTTUrl(lang.path) === path.posix.normalize(req.url ?? ""));
+		const languages = context.manifest.languages.filter((lang) => localToFoundryVTTUrl(lang.path) === path.posix.normalize(request.url ?? ""));
 		if (languages.length === 1) {
 			const lang = languages[0].lang;
 			const language = await loadLanguage(lang);
 			const jsonData = transform(language);
-			res.setHeader("Content-Type", "application/json");
-			res.end(JSON.stringify(jsonData, null, 2));
+			response.setHeader("Content-Type", "application/json");
+			response.end(JSON.stringify(jsonData, void 0, 2));
 			return;
 		}
 		next();
@@ -510,34 +528,34 @@ function httpMiddlewareHook(server) {
 //#endregion
 //#region src/server/socket-proxy.ts
 function socketProxy(server) {
-	const env = context.env;
+	const environment = context.env;
 	new Server(server.httpServer, { path: "/socket.io" }).on("connection", (socket) => {
-		const upstream = io(`http://${env.foundryUrl}:${env.foundryPort}`, {
+		const upstream = io(`http://${environment.foundryUrl}:${environment.foundryPort}`, {
 			transports: ["websocket"],
 			upgrade: false,
 			query: socket.handshake.query
 		});
-		socket.onAny(async (event, ...args) => {
-			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
+		socket.onAny(async (event, ...parameters) => {
+			const maybeAck = typeof parameters.at(-1) === "function" ? parameters.pop() : void 0;
 			if (event === "template") {
-				const localPath = await path_utils_default.foundryVTTUrlToLocal(args[0]);
+				const localPath = await foundryVTTUrlToLocal(parameters[0]);
 				if (localPath) {
-					const html = await fs_utils_default.readFile(localPath);
+					const html = await readFile(localPath);
 					if (maybeAck) maybeAck({
 						html,
 						success: true
 					});
-					handlebarsTracker.addFile(args[0], localPath);
+					handlebarsTracker.addFile(parameters[0], localPath);
 					return;
 				}
 			}
-			upstream.emit(event, ...args, (response) => {
+			upstream.emit(event, ...parameters, (response) => {
 				if (maybeAck) maybeAck(response);
 			});
 		});
-		upstream.onAny((event, ...args) => {
-			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
-			socket.emit(event, ...args, (response) => {
+		upstream.onAny((event, ...parameters) => {
+			const maybeAck = typeof parameters.at(-1) === "function" ? parameters.pop() : void 0;
+			socket.emit(event, ...parameters, (response) => {
 				if (maybeAck) maybeAck(response);
 			});
 		});
@@ -546,7 +564,7 @@ function socketProxy(server) {
 
 //#endregion
 //#region src/server/index.ts
-function setupDevServer(server) {
+function setupDevelopmentServer(server) {
 	handlebarsTracker.initialize(server);
 	languageTracker.initialize(server);
 	httpMiddlewareHook(server);
@@ -559,18 +577,12 @@ var hmr_client_default = `
 if (import.meta.hot) {
   const FVTT_PLUGIN = __FVTT_PLUGIN__
 
-  function refreshApplications(path = null) {
+  function refreshApplications(renderData = {}) {
+    const options = { renderContext: 'hotReload', renderData }
     // AppV1 refresh
-    Object.values(foundry.ui.windows).forEach(app => app.render(true))
+    for (const appV1 of Object.values(foundry.ui.windows)) appV1.render(false, { ...options })
     // AppV2 refresh
-    if (path)
-      foundry.applications.instances.forEach(appV2 => {
-        Object.values(appV2.constructor.PARTS ?? {}).forEach(part => {
-          const templates = Array.isArray(part.templates) ? part.templates : []
-          if (part.template === path || templates.includes(path)) appV2.render(true)
-        })
-      })
-    else foundry.applications.instances.forEach(appV2 => appV2.render(true))
+    for (const appV2 of foundry.applications.instances.values()) appV2.render({ ...options })
   }
 
   import.meta.hot.on('foundryvtt-template-update', ({ path }) => {
@@ -583,9 +595,19 @@ if (import.meta.hot) {
         console.error(error)
         return
       }
-      Handlebars.registerPartial(path, template)
+      if (!Object.hasOwn(Handlebars, 'templateIds')) Handlebars.registerPartial(path, template)
+      else if (Handlebars.templateIds[path]?.size > 0) {
+        for (const id of Handlebars.templateIds[path])
+          if (id in Handlebars.partials) Handlebars.registerPartial(id, template)
+      } else foundry.applications.handlebars.getTemplate(path)
       console.log(\`Vite | Retrieved and compiled template \${path}\`)
-      refreshApplications(path)
+      refreshApplications({
+        packageId: FVTT_PLUGIN.id,
+        packageType: FVTT_PLUGIN.isSystem ? 'system' : 'module',
+        content: response.html,
+        path,
+        extension: 'html',
+      })
     })
   })
 
@@ -615,7 +637,7 @@ if (import.meta.hot) {
       foundry.utils.mergeObject(targetObject, json)
       console.log(\`Vite | HMR: Reloaded language '\${lang}'\`)
     } catch (error) {
-      console.error(\`Vite | HMR: Error reloading language '\${lang}' for \${FVTT_PLUGIN.id}\`, error);
+      console.error(\`Vite | HMR: Error reloading language '\${lang}' for \${FVTT_PLUGIN.id}\`, error)
     }
   }
 
@@ -627,15 +649,21 @@ if (import.meta.hot) {
     }
     promises.push(hmrLanguage(currentLang))
     await Promise.all(promises)
-    refreshApplications()
+    refreshApplications({
+      packageId: FVTT_PLUGIN.id,
+      packageType: FVTT_PLUGIN.isSystem ? 'system' : 'module',
+      content: '',
+      path: '',
+      extension: 'json',
+    })
   })
 } else console.error('Vite | HMR is disabled')
 //`;
 
 //#endregion
 //#region src/index.ts
-async function foundryVTTPlugin(options = { buildPacks: true }) {
-	context.env = await loadEnv();
+async function foundryVTTPlugin({ buildPacks = true } = {}) {
+	context.env = await loadEnvironment();
 	return {
 		name: "vite-plugin-fvtt",
 		async config(config) {
@@ -647,44 +675,47 @@ async function foundryVTTPlugin(options = { buildPacks: true }) {
 		},
 		async generateBundle() {
 			for (const file of ["system.json", "module.json"]) {
-				const src = path.resolve(file);
-				if (!await path_utils_default.getPublicDirFile(file) && await fs_utils_default.fileExists(src)) {
-					this.addWatchFile(src);
-					const manifest = await fs_utils_default.readJson(src);
+				const source = path.resolve(file);
+				if (!await getPublicDirectoryFile(file) && await fileExists(source)) {
+					this.addWatchFile(source);
+					const manifest = await readJson(source);
 					this.emitFile({
 						type: "asset",
 						fileName: file,
-						source: JSON.stringify(manifest, null, 2)
+						source: JSON.stringify(manifest, void 0, 2)
 					});
 				}
 			}
 			const languages = context.manifest?.languages ?? [];
 			if (languages.length > 0) for (const language of languages) {
-				if (await path_utils_default.getPublicDirFile(language.path)) continue;
+				if (await getPublicDirectoryFile(language.path)) continue;
 				getLocalLanguageFiles(language.lang).then((langFiles) => {
-					langFiles.forEach((file) => this.addWatchFile(file));
+					for (const file of langFiles) this.addWatchFile(file);
 				});
 				const languageDataRaw = await loadLanguage(language.lang);
 				const languageData = transform(languageDataRaw);
 				this.emitFile({
 					type: "asset",
 					fileName: path.join(language.path),
-					source: JSON.stringify(languageData, null, 2)
+					source: JSON.stringify(languageData, void 0, 2)
 				});
 			}
 		},
 		async writeBundle() {
-			if (options.buildPacks) await compileManifestPacks();
+			if (buildPacks) await compileManifestPacks();
 		},
 		closeBundle() {
 			if ((context.manifest?.languages ?? []).length > 0) validator();
 		},
 		load(id) {
 			const config = context.config;
-			const jsFileName = (config.build.rollupOptions?.output).entryFileNames;
+			const output = config.build.rollupOptions?.output;
+			let jsFileName;
+			if (Array.isArray(output)) jsFileName = String(output[0].entryFileNames);
+			else if (output) jsFileName = String(output.entryFileNames);
 			if (id === jsFileName || id === `/${jsFileName}`) return `import '${`/@fs/${path.resolve(config.build.lib.entry)}`}';\n${hmr_client_default}`;
 		},
-		configureServer: setupDevServer
+		configureServer: setupDevelopmentServer
 	};
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-fvtt",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "A Vite plugin for module and system development for Foundry VTT",
   "keywords": [
     "vite",
@@ -27,14 +27,19 @@
     "README.md"
   ],
   "scripts": {
-    "dev": "tsdown --watch",
     "build": "tsdown",
+    "dev": "tsdown --watch",
+    "eslint": "eslint .",
+    "prettier": "prettier --check .",
+    "typecheck": "tsc",
     "test": "vitest"
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",
     "@types/node": "^24.3.0",
     "eslint": "^9.34.0",
+    "eslint-plugin-sonarjs": "^3.0.5",
+    "eslint-plugin-unicorn": "^61.0.2",
     "prettier": "^3.6.2",
     "tsdown": "^0.15.1",
     "typescript": "^5.9.2",