vite-plugin-fvtt 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 MatyeusM
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,86 @@
+# **vite-plugin-fvtt**
+
+A powerful [Vite](https://vitejs.dev/) plugin to **streamline and automate** the development of Foundry VTT modules and systems. It handles manifest resolution, asset copying, language file composition, and template handling with **minimal setup**, letting you focus on your code.
+
+## **🚀 Key Features**
+
+The primary advantage of this plugin is the ability to develop your module in a modern, isolated environment. You no longer need to work directly inside your Foundry VTT data folder, which can be messy and inefficient. This allows you to leverage Vite's Hot Module Replacement (HMR) and other developer-friendly features without polluting your local installation.
+
+## **Getting Started**
+
+### **1. Setup a Foundry VTT Project**
+
+Create a standard [Foundry VTT module or system](https://foundryvtt.com/article/module-development/).
+Place your `module.json` or `system.json` manifest in either your **project root** or your **public/** directory.
+
+### **2. Add the Plugin to your Vite Config**
+
+Install the plugin with `npm i -D vite-plugin-fvtt`.
+
+Add the plugin to your vite.config.js. The **build.lib.entry** field is required, most of the other settings are infer'd by the plugin from your foundry manifest.
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import foundryVTT from 'vite-plugin-fvtt';
+
+export default defineConfig({
+  plugins: [foundryVTT()],
+  build: {
+    // ⚠️ Required: The entry point for your module/system.
+    // This file should import your main CSS/SCSS/LESS file.
+    lib: {
+      entry: './src/main.js',
+    },
+    sourcemap: true,
+  },
+});
+```
+
+## **⚙️ How it Works**
+
+### **Manifest & Asset Resolution**
+
+* The plugin automatically detects your manifest file (`module.json` or `system.json`) in the project **root** or `public/` folder.
+* Assets referenced in the manifest (styles, esmodules, scripts) are **automatically generated to the build output**, simplifying your build process.
+
+### **Template Handling**
+
+* The plugin automatically detects templates in common locations:
+  * Your public folder (e.g., `public/handlebars/`).
+  * The project root (e.g., `templates/`).
+  * A templates folder directly under your entry file's directory (e.g., `src/tpl/`).
+* **Note:** Only templates located in the **public folder** are copied to the build output.
+
+### **Language File Merging**
+
+The plugin offers a powerful feature for managing translations.
+
+* **Complete Language Files:** Place a complete JSON file (e.g., `public/lang/en.json`) and the plugin will copy it as-is.
+* **Partial Language Files:** To modularize your translations, place multiple JSON files in a subdirectory (e.g., `src/lang/en/`). The plugin will automatically **merge them into a single file** (`lang/en.json`) during the build, as specified in your manifest. The plugin looks in **root** or your **source directory** for the paths as specified in your foundry manifest file.
+
+## **Example Project Structure**
+```
+my-module/
+├─ src/
+│  ├─ main.js         # The primary module entry file (required by Vite).
+│  ├─ style.css       # Your project's main stylesheet.
+│  └─ lang/en/        # Directory for partial, merged translation files.
+│     ├─ spells.json
+│     ├─ abilities.json
+│     └─ general.json
+├─ public/
+│  ├─ module.json     # Your module's manifest file (or system.json).
+│  └─ templates/      # HTML template files for your module.
+├─ vite.config.js     # Your Vite configuration file.
+```
+
+## **🐛 Known Issues & Troubleshooting**
+
+* **HMR:** Hot Module Replacement may be inconsistent for non-English language files. A full page refresh or server restart might be needed.
+* **App V2:** HMR for Foundry's new App V2 has not been fully tested. If you encounter issues, please open a GitHub issue.
+* **General Issues:** If you face unexpected behavior, the first step is always to **restart your dev server (npm run dev) or run a fresh build**. This often resolves caching or HMR-related glitches.
+
+---
+
+License: MIT

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+declare function foundryVTTPlugin(): Plugin;
+//#endregion
+export { foundryVTTPlugin as default };

package/dist/index.js

@@ -0,0 +1,534 @@
+import fs from "fs-extra";
+import posix from "path/posix";
+import dotenv from "dotenv";
+import { sync } from "glob";
+import { Server } from "socket.io";
+import { io } from "socket.io-client";
+
+//#region src/context.ts
+const context = {};
+
+//#endregion
+//#region src/config/env.ts
+function loadEnv() {
+	const envPath = posix.resolve(process.cwd(), ".env.foundryvtt.local");
+	const { parsed } = dotenv.config({
+		path: envPath,
+		quiet: true
+	});
+	return {
+		foundryUrl: parsed?.FOUNDRY_URL ?? "localhost",
+		foundryPort: parseInt(parsed?.FOUNDRY_PORT ?? "30000", 10)
+	};
+}
+
+//#endregion
+//#region src/config/foundryvtt-manifest.ts
+function loadManifest(config) {
+	if (context?.manifest) return context.manifest;
+	const publicDir = config.publicDir || "public";
+	const MANIFEST_LOCATIONS = [
+		"system.json",
+		"module.json",
+		`${publicDir}/system.json`,
+		`${publicDir}/module.json`
+	];
+	const foundPath = MANIFEST_LOCATIONS.map((relPath) => posix.resolve(process.cwd(), relPath)).find((absPath) => fs.pathExistsSync(absPath));
+	if (!foundPath) throw new Error(`Could not find a manifest file (system.json or module.json) in project root or ${publicDir}/.`);
+	try {
+		const data = fs.readJsonSync(foundPath);
+		data.manifestType = foundPath.includes("module.json") ? "module" : "system";
+		return data;
+	} catch (err) {
+		throw new Error(`Failed to read manifest at ${foundPath}: ${err?.message || err}`);
+	}
+}
+
+//#endregion
+//#region src/utils/logger.ts
+var Logger = class {
+	namespace;
+	colors = {
+		info: "\x1B[32m",
+		warn: "\x1B[33m",
+		error: "\x1B[31m"
+	};
+	constructor({ namespace = "vite-plugin-foundryvtt" } = {}) {
+		this.namespace = namespace;
+	}
+	format(level, message) {
+		const color = this.colors[level] ?? "";
+		const reset = "\x1B[0m";
+		return `${color}[${this.namespace}] [${level.toUpperCase()}]${reset} ${message}`;
+	}
+	info(message) {
+		console.log(this.format("info", message));
+	}
+	warn(message) {
+		console.warn(this.format("warn", message));
+	}
+	error(message) {
+		console.error(this.format("error", message));
+	}
+	fail(message) {
+		this.error(message);
+		throw new Error(typeof message === "string" ? message : JSON.stringify(message, null, 2));
+	}
+};
+var logger_default = new Logger();
+
+//#endregion
+//#region src/config/vite-options.ts
+function createPartialViteConfig(config) {
+	const base = config.base ?? `/${context.manifest?.manifestType}s/${context.manifest?.id}/`;
+	const useEsModules = context.manifest?.esmodules.length === 1;
+	const formats = useEsModules ? ["es"] : ["umd"];
+	const fileName = (useEsModules ? context.manifest?.esmodules[0] : context.manifest?.scripts?.[0]) ?? "bundle";
+	if (fileName === "bundle") logger_default.warn("No output file specified in manifest, using default \"bundle\"");
+	if (!context.manifest?.styles?.length) logger_default.warn("No CSS file found in manifest");
+	const cssFileName = posix.parse(context.manifest?.styles[0] ?? "").name;
+	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");
+	return {
+		base,
+		esbuild: config.esbuild ?? {
+			minifyIdentifiers: false,
+			minifySyntax: true,
+			minifyWhitespace: true,
+			keepNames: true
+		},
+		server: {
+			port: foundryPort + 1,
+			proxy: { [`^(?!${base})`]: `http://${foundryUrl}:${foundryPort}` }
+		},
+		build: {
+			minify: "esbuild",
+			lib: {
+				cssFileName,
+				entry,
+				fileName,
+				formats,
+				name: context.manifest?.id
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/server/hmr-client.ts
+var hmr_client_default = `
+if (import.meta.hot) {
+  function refreshApplications() {
+    // AppV1 refresh
+    Object.values(foundry.ui.windows).forEach(app => app.render(true))
+    // AppV2 refresh
+    // TODO: Can we filter out to only refresh the correct apps?
+    foundry.applications.instances.forEach(appV2 => appV2.render(true))
+  }
+
+  import.meta.hot.on('foundryvtt-template-update', async ({ path }) => {
+    console.log('Vite | Force reload template', path)
+    Handlebars.unregisterPartial(path)
+    await foundry.applications.handlebars.getTemplate(path)
+    refreshApplications()
+  })
+
+  import.meta.hot.on('foundryvtt-language-update', async () => {
+    console.log('Vite | Force reassigning language')
+    await game.i18n.setLanguage(game.i18n.lang)
+    refreshApplications()
+  })
+} else console.error('Vite | HMR is disabled')
+`;
+
+//#endregion
+//#region src/server/trackers/abstract-file-tracker.ts
+var AbstractFileTracker = class {
+	initialized = false;
+	tracked = /* @__PURE__ */ new Map();
+	watcher = null;
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	initialize(server) {
+		if (this.initialized) return;
+		this.initialized = true;
+		this.watcher = server.watcher;
+		this.watcher.on("change", (changedPath) => {
+			const value = this.tracked.get(changedPath);
+			if (!value) return;
+			logger_default.info(`Attempting to hot reload ${changedPath}`);
+			const eventData = this.getEventData(changedPath, value);
+			server.ws.send({
+				type: "custom",
+				event: this.updateEvent,
+				data: eventData
+			});
+		});
+	}
+	addFile(value, filePath) {
+		const absPath = posix.resolve(filePath);
+		if (!this.tracked.has(absPath)) {
+			this.tracked.set(absPath, value);
+			this.watcher?.add(absPath);
+		}
+	}
+};
+
+//#endregion
+//#region src/server/trackers/handlebars-tracker.ts
+var HandlebarsTracker = class extends AbstractFileTracker {
+	updateEvent = "foundryvtt-template-update";
+	constructor() {
+		super(context.config);
+	}
+	getEventData(changedPath, value) {
+		return { path: value };
+	}
+};
+const handlebarsTracker = new HandlebarsTracker();
+
+//#endregion
+//#region src/server/trackers/language-tracker.ts
+var LanguageTracker = class extends AbstractFileTracker {
+	updateEvent = "foundryvtt-language-update";
+	constructor() {
+		super({});
+	}
+	getEventData() {
+		return {};
+	}
+};
+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 = PathUtils.normalize(decodeURI(config.base));
+		}
+		return PathUtils._decodedBase;
+	}
+	static getSourceDirectory() {
+		if (!PathUtils._sourceDirectory) {
+			const config = PathUtils.getConfig();
+			const normalizedEntry = PathUtils.normalize(config.build.lib.entry.toString());
+			const segments = normalizedEntry.split(posix.sep).filter(Boolean).filter((s) => s !== ".");
+			const firstFolder = segments.length > 0 ? segments[0] : ".";
+			PathUtils._sourceDirectory = posix.join(config.root, firstFolder);
+		}
+		return PathUtils._sourceDirectory;
+	}
+	static getPublicDir() {
+		if (!PathUtils._publicDir) {
+			const config = PathUtils.getConfig();
+			PathUtils._publicDir = PathUtils.normalize(posix.resolve(config.publicDir));
+		}
+		return PathUtils._publicDir;
+	}
+	static getOutDir() {
+		if (!PathUtils._outDir) {
+			const config = PathUtils.getConfig();
+			PathUtils._outDir = PathUtils.normalize(posix.resolve(config.build.outDir));
+		}
+		return PathUtils._outDir;
+	}
+	static getRoot() {
+		if (!PathUtils._root) {
+			const config = PathUtils.getConfig();
+			PathUtils._root = PathUtils.normalize(config.root);
+		}
+		return PathUtils._root;
+	}
+	static getOutDirFile(p) {
+		const file = posix.join(PathUtils.getOutDir(), p);
+		return fs.existsSync(file) ? file : "";
+	}
+	static getPublicDirFile(p) {
+		const file = posix.join(PathUtils.getPublicDir(), p);
+		return fs.existsSync(file) ? file : "";
+	}
+	static normalize(p) {
+		return posix.normalize(p);
+	}
+	static findLocalFilePath(p) {
+		const fileCandidates = [
+			PathUtils.getPublicDir(),
+			PathUtils.getSourceDirectory(),
+			PathUtils.getRoot()
+		].map((pth) => posix.join(pth, p));
+		return fileCandidates.find((pth) => fs.existsSync(pth)) ?? null;
+	}
+	static isFoundryVTTUrl(p) {
+		const decodedBase = PathUtils.getDecodedBase();
+		const pathToCheck = PathUtils.normalize(p);
+		return pathToCheck.startsWith(decodedBase);
+	}
+	static foundryVTTUrlToLocal(p) {
+		const decodedBase = PathUtils.getDecodedBase();
+		let pathToTransform = PathUtils.normalize("/" + p);
+		if (!pathToTransform.startsWith(decodedBase)) return null;
+		pathToTransform = posix.relative(decodedBase, pathToTransform);
+		return PathUtils.findLocalFilePath(pathToTransform);
+	}
+	static localToFoundryVTTUrl(p) {
+		const decodedBase = PathUtils.getDecodedBase();
+		let pathToTransform = PathUtils.normalize(p);
+		[
+			PathUtils.getPublicDir(),
+			PathUtils.getSourceDirectory(),
+			PathUtils.getRoot()
+		].forEach((pth) => {
+			if (pathToTransform.startsWith(pth)) pathToTransform = pathToTransform.slice(pth.length);
+		});
+		return posix.join(decodedBase, pathToTransform);
+	}
+	static getLanguageSourcePath(p, lang) {
+		const dir = posix.parse(p).dir;
+		const lastDirName = posix.basename(dir);
+		const finalSegments = lastDirName === lang ? dir : posix.join(dir, lang);
+		return posix.join(PathUtils.getSourceDirectory(), finalSegments);
+	}
+};
+var path_utils_default = PathUtils;
+
+//#endregion
+//#region src/language/loader.ts
+function getLocalLanguageFiles(lang, outDir = false) {
+	const manifest = context.manifest;
+	const language = manifest.languages.find((l) => l.lang === lang);
+	if (!language) logger_default.fail(`Cannot find language "${lang}"`);
+	const langPath = language?.path ?? "";
+	if (outDir) {
+		const languageFile = path_utils_default.getOutDirFile(langPath);
+		return [languageFile];
+	}
+	const publicDirFile = 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 sync(posix.join(sourcePath, "**/*.json"));
+}
+function loadLanguage(lang, outDir = false) {
+	const files = 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);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/language/transformer.ts
+function flattenKeys(obj, prefix = "") {
+	const result = {};
+	for (const [key, val] of Object.entries(obj)) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		if (val && typeof val === "object" && !Array.isArray(val)) Object.assign(result, flattenKeys(val, fullKey));
+		else result[fullKey] = val;
+	}
+	return result;
+}
+function expandDotNotationKeys(target, source, depth = 0) {
+	if (depth > 32) logger_default.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;
+		const parts = key.split(".");
+		const lastKey = parts.pop();
+		for (const part of parts) {
+			if (!(part in current)) current[part] = {};
+			current = current[part];
+		}
+		if (lastKey in current) console.warn(`Warning: Overwriting key "${lastKey}" during transformation.`);
+		current[lastKey] = expandDotNotationKeys({}, value, depth + 1);
+	}
+	return target;
+}
+function transform(dataMap) {
+	const mergedData = {};
+	for (const data of dataMap.values()) expandDotNotationKeys(mergedData, data);
+	return mergedData;
+}
+
+//#endregion
+//#region src/server/http-middleware.ts
+function httpMiddlewareHook(server) {
+	server.middlewares.use((req, res, next) => {
+		const config = context.config;
+		if (!path_utils_default.isFoundryVTTUrl(req.url ?? "")) {
+			next();
+			return;
+		}
+		const cssFileName = config.build.lib.cssFileName;
+		const cssEntry = cssFileName ? path_utils_default.localToFoundryVTTUrl(`${cssFileName}.css`) : null;
+		if (path_utils_default.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. */");
+			return;
+		}
+		const languages = context.manifest.languages.filter((lang) => path_utils_default.localToFoundryVTTUrl(lang.path) === path_utils_default.normalize(req.url ?? ""));
+		if (languages.length === 1) {
+			const lang = languages[0].lang;
+			const language = loadLanguage(lang);
+			const jsonData = transform(language);
+			res.setHeader("Content-Type", "application/json");
+			res.end(JSON.stringify(jsonData, null, 2));
+			return;
+		}
+		next();
+	});
+}
+
+//#endregion
+//#region src/server/socket-proxy.ts
+function socketProxy(server) {
+	const env = context.env;
+	const ioProxy = new Server(server.httpServer, { path: "/socket.io" });
+	ioProxy.on("connection", (socket) => {
+		const upstream = io(`http://${env.foundryUrl}:${env.foundryPort}`, {
+			transports: ["websocket"],
+			upgrade: false,
+			query: socket.handshake.query
+		});
+		socket.onAny((event, ...args) => {
+			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
+			if (event === "template") {
+				const localPath = path_utils_default.foundryVTTUrlToLocal(args[0]);
+				if (localPath) {
+					if (maybeAck) maybeAck({
+						html: fs.readFileSync(localPath, "utf8"),
+						success: true
+					});
+					handlebarsTracker.addFile(args[0], localPath);
+					return;
+				}
+			}
+			upstream.emit(event, ...args, (response) => {
+				if (maybeAck) maybeAck(response);
+			});
+		});
+		upstream.onAny((event, ...args) => {
+			const lastArg = args[args.length - 1];
+			const maybeAck = typeof lastArg === "function" ? args.pop() : null;
+			socket.emit(event, ...args, (response) => {
+				if (maybeAck) maybeAck(response);
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/server/index.ts
+function setupDevServer(server) {
+	handlebarsTracker.initialize(server);
+	languageTracker.initialize(server);
+	httpMiddlewareHook(server);
+	socketProxy(server);
+}
+
+//#endregion
+//#region src/language/validator.ts
+function validator() {
+	const manifest = context.manifest;
+	const baseLanguageData = loadLanguage("en", true);
+	if (baseLanguageData.size === 0) {
+		logger_default.error("Base language \"en\" not found or could not be loaded.");
+		return;
+	}
+	const base = flattenKeys(baseLanguageData.values().next().value);
+	for (const lang of manifest.languages) {
+		if (lang.lang === "en") continue;
+		const currentLanguageData = loadLanguage(lang.lang, true);
+		if (currentLanguageData.size === 0) {
+			console.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));
+		console.log(`Summary for language [${lang.lang}]:`);
+		if (missing.length) console.warn(`\tMissing keys: ${missing.length}`, missing.slice(0, 5));
+		if (extra.length) console.warn(`\tExtra keys: ${extra.length}`, extra.slice(0, 5));
+		if (!missing.length && !extra.length) console.log("	✅ All keys match.");
+	}
+}
+
+//#endregion
+//#region src/index.ts
+function foundryVTTPlugin() {
+	context.env = loadEnv();
+	return {
+		name: "vite-plugin-foundryvtt",
+		config(config) {
+			context.manifest = loadManifest(config);
+			return createPartialViteConfig(config);
+		},
+		configResolved(config) {
+			context.config = config;
+		},
+		async closeBundle() {
+			if (context.config?.mode !== "production") return;
+			const outDir = posix.resolve(process.cwd(), context.config.build.outDir);
+			const candidates = ["system.json", "module.json"];
+			for (const file of candidates) {
+				const src = posix.resolve(process.cwd(), file);
+				if (await fs.pathExists(src)) {
+					const dest = posix.join(outDir, file);
+					await fs.copy(src, dest);
+					logger_default.info(`Copied ${file} >>> ${dest}`);
+				}
+			}
+			const languages = context.manifest?.languages ?? [];
+			if (languages.length > 0) {
+				for (const language of languages) {
+					if (path_utils_default.getOutDirFile(language.path) !== "") continue;
+					const languageDataRaw = loadLanguage(language.lang);
+					const languageData = transform(languageDataRaw);
+					fs.writeJSONSync(posix.join(path_utils_default.getOutDir(), language.path), languageData);
+				}
+				validator();
+			}
+		},
+		load(id) {
+			const config = context.config;
+			const jsFileName = config.build.lib.fileName;
+			if (id === jsFileName || id === `/${jsFileName}`) {
+				const entryPath = posix.resolve(config.build.lib.entry);
+				const viteId = `/@fs/${entryPath}`;
+				return `import '${viteId}';\n${hmr_client_default}`;
+			}
+		},
+		configureServer: setupDevServer
+	};
+}
+
+//#endregion
+export { foundryVTTPlugin as default };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "vite-plugin-fvtt",
+  "version": "0.1.1",
+  "description": "A Vite plugin for module and system development for Foundry VTT",
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "foundryvtt"
+  ],
+  "homepage": "https://github.com/MatyeusM/vite-plugin-fvtt#readme",
+  "bugs": {
+    "url": "https://github.com/MatyeusM/vite-plugin-fvtt/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MatyeusM/vite-plugin-fvtt.git"
+  },
+  "license": "MIT",
+  "author": "MatyeusM (https://github.com/MatyeusM)",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown"
+  },
+  "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",
+    "tsdown": "^0.14.2",
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.41.0",
+    "vite": "*"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.1",
+    "fs-extra": "^11.3.1",
+    "glob": "^11.0.3",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1"
+  },
+  "peerDependencies": {
+    "vite": "^7.0.0"
+  }
+}