vite-plugin-fvtt 0.2.5 → 0.2.7

package/dist/index.mjs

@@ -0,0 +1,717 @@
+import path from "node:path";
+import { glob } from "tinyglobby";
+import fs from "node:fs/promises";
+import { compilePack } from "@foundryvtt/foundryvtt-cli";
+import { Server } from "socket.io";
+import { io } from "socket.io-client";
+
+//#region src/context.ts
+const context = {};
+
+//#endregion
+//#region src/utils/fs-utilities.ts
+async function checkType(p, check) {
+	try {
+		return check(await fs.stat(p));
+	} catch {
+		return false;
+	}
+}
+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;
+	}
+}
+
+//#endregion
+//#region src/config/environment.ts
+function parseEnvironment(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 loadEnvironment() {
+	const environmentPaths = await glob(".env.foundryvtt*", { absolute: true });
+	let merged = {
+		FOUNDRY_URL: "localhost",
+		FOUNDRY_PORT: "30000"
+	};
+	for (const file of environmentPaths) {
+		const content = await readFile(file);
+		merged = {
+			...merged,
+			...parseEnvironment(content)
+		};
+	}
+	return {
+		foundryUrl: merged.FOUNDRY_URL,
+		foundryPort: Number.parseInt(merged.FOUNDRY_PORT, 10)
+	};
+}
+
+//#endregion
+//#region src/utils/logger.ts
+let loggerNamespace = "vite-plugin-fvtt";
+const colors = {
+	info: "\x1B[36m",
+	warn: "\x1B[33m",
+	error: "\x1B[31m"
+};
+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 resolveManifestPath(publicDirectory) {
+	const paths = [
+		"system.json",
+		"module.json",
+		`${publicDirectory}/system.json`,
+		`${publicDirectory}/module.json`
+	].map((f) => path.resolve(process.cwd(), f));
+	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 {
+		return validateManifest(await readJson(foundPath), 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)}`);
+	}
+}
+
+//#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]) ?? "scripts/bundle.js";
+	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]) 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 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,
+		build: {
+			emptyOutDir: config.build?.emptyOutDir ?? !isWatch,
+			lib: {
+				entry,
+				formats,
+				name: context.manifest?.id ?? "bundle",
+				cssFileName: "bundle"
+			},
+			minify: "esbuild",
+			rollupOptions: { output: {
+				entryFileNames: fileName,
+				assetFileNames: (assetInfo) => {
+					if ((assetInfo.names ?? []).some((n) => n.endsWith(".css"))) return cssFileName;
+					return "[name][extname]";
+				}
+			} }
+		},
+		define: { __FVTT_PLUGIN__: {
+			id: context.manifest?.id,
+			isSystem: context.manifest?.manifestType === "system"
+		} },
+		esbuild: config.esbuild ?? {
+			minifyIdentifiers: false,
+			minifySyntax: true,
+			minifyWhitespace: true,
+			keepNames: true
+		},
+		server: {
+			port: foundryPort + 1,
+			proxy: { [`^(?!${base})`]: `http://${foundryUrl}:${foundryPort}` }
+		}
+	};
+}
+
+//#endregion
+//#region src/server/trackers/abstract-file-tracker.ts
+var AbstractFileTracker = class {
+	initialized = false;
+	tracked = /* @__PURE__ */ new Map();
+	watcher = void 0;
+	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;
+			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 = path.resolve(filePath);
+		if (!this.tracked.has(absPath)) {
+			this.tracked.set(absPath, value);
+			this.watcher?.add(absPath);
+		}
+	}
+};
+
+//#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-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;
+	}
+	return _config;
+}
+function getDecodedBase() {
+	if (!_decodedBase) {
+		const config = getConfig();
+		_decodedBase = path.posix.normalize(decodeURI(config.base));
+	}
+	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);
+	}
+	return _publicDirectory;
+}
+function getOutDirectory() {
+	if (!_outDirectory) {
+		const config = getConfig();
+		_outDirectory = path.resolve(config.build.outDir);
+	}
+	return _outDirectory;
+}
+function getRoot() {
+	if (!_root) {
+		const config = getConfig();
+		_root = path.resolve(config.root);
+	}
+	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, inOutDirectory = false) {
+	const language = context.manifest.languages.find((l) => l.lang === lang);
+	if (!language) fail(`Cannot find language "${lang}"`);
+	const langPath = language?.path ?? "";
+	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, inOutDirectory = false) {
+	const files = await getLocalLanguageFiles(lang, inOutDirectory);
+	const result = /* @__PURE__ */ new Map();
+	const reads = files.map(async (file) => {
+		try {
+			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 (error$1) {
+			warn(error$1);
+			return;
+		}
+	});
+	const results = await Promise.all(reads);
+	for (const entry of results) if (entry) result.set(entry[0], entry[1]);
+	return result;
+}
+
+//#endregion
+//#region src/language/transformer.ts
+function flattenKeys(object, prefix = "") {
+	const result = {};
+	for (const [key, value] of Object.entries(object)) {
+		const fullKey = prefix ? `${prefix}.${key}` : key;
+		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) 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/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 base = getFirstMapValueOrWarn(await loadLanguage("en", true), "Base language \"en\"");
+	if (!base) {
+		error("Base language \"en\" not found or could not be loaded.");
+		return;
+	}
+	const baseFlattened = flattenKeys(base);
+	for (const lang of manifest.languages) {
+		if (lang.lang === "en") continue;
+		const current = getFirstMapValueOrWarn(await loadLanguage(lang.lang, true), `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.");
+	}
+}
+
+//#endregion
+//#region src/packs/compile-packs.ts
+async function compileManifestPacks() {
+	if (!context.manifest?.packs) return;
+	for (const pack of context.manifest.packs) {
+		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 (!chosenSource) {
+			warn(`Pack path not found for ${pack.path}, skipped.`);
+			continue;
+		}
+		const hasYaml = (await glob(["**/*.yaml", "**/*.yml"], {
+			cwd: chosenSource,
+			absolute: true
+		})).length > 0;
+		await compilePack(chosenSource, destination, {
+			yaml: hasYaml,
+			recursive: true
+		});
+		info(`Compiled pack ${pack.path} (${hasYaml ? "YAML" : "JSON"}) from ${chosenSource}`);
+	}
+}
+
+//#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/http-middleware.ts
+function httpMiddlewareHook(server) {
+	server.middlewares.use(async (request, response, next) => {
+		const config = context.config;
+		if (!isFoundryVTTUrl(request.url ?? "")) {
+			next();
+			return;
+		}
+		const cssFileName = config.build.lib.cssFileName;
+		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) => localToFoundryVTTUrl(lang.path) === path.posix.normalize(request.url ?? ""));
+		if (languages.length === 1) {
+			const lang = languages[0].lang;
+			const jsonData = transform(await loadLanguage(lang));
+			response.setHeader("Content-Type", "application/json");
+			response.end(JSON.stringify(jsonData, void 0, 2));
+			return;
+		}
+		next();
+	});
+}
+
+//#endregion
+//#region src/server/socket-proxy.ts
+function socketProxy(server) {
+	const environment = context.env;
+	new Server(server.httpServer, { path: "/socket.io" }).on("connection", (socket) => {
+		const upstream = io(`http://${environment.foundryUrl}:${environment.foundryPort}`, {
+			transports: ["websocket"],
+			upgrade: false,
+			query: socket.handshake.query
+		});
+		socket.onAny(async (event, ...parameters) => {
+			const maybeAck = typeof parameters.at(-1) === "function" ? parameters.pop() : void 0;
+			if (event === "template") {
+				const localPath = await foundryVTTUrlToLocal(parameters[0]);
+				if (localPath) {
+					const html = await readFile(localPath);
+					if (maybeAck) maybeAck({
+						html,
+						success: true
+					});
+					handlebarsTracker.addFile(parameters[0], localPath);
+					return;
+				}
+			}
+			upstream.emit(event, ...parameters, (response) => {
+				if (maybeAck) maybeAck(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);
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/server/index.ts
+function setupDevelopmentServer(server) {
+	handlebarsTracker.initialize(server);
+	languageTracker.initialize(server);
+	httpMiddlewareHook(server);
+	socketProxy(server);
+}
+
+//#endregion
+//#region src/server/hmr-client.ts
+var hmr_client_default = `
+if (import.meta.hot) {
+  const FVTT_PLUGIN = __FVTT_PLUGIN__
+
+  function refreshApplications(renderData = {}) {
+    const options = { renderContext: 'hotReload', renderData }
+    // AppV1 refresh
+    for (const appV1 of Object.values(foundry.ui.windows)) appV1.render(false, { ...options })
+    // AppV2 refresh
+    for (const appV2 of foundry.applications.instances.values()) appV2.render({ ...options })
+  }
+
+  import.meta.hot.on('foundryvtt-template-update', ({ path }) => {
+    game.socket.emit('template', path, response => {
+      if (response.error) new Error(response.error)
+      let template = undefined
+      try {
+        template = Handlebars.compile(response.html)
+      } catch (error) {
+        console.error(error)
+        return
+      }
+      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({
+        packageId: FVTT_PLUGIN.id,
+        packageType: FVTT_PLUGIN.isSystem ? 'system' : 'module',
+        content: response.html,
+        path,
+        extension: 'html',
+      })
+    })
+  })
+
+  async function hmrLanguage(lang, targetObject = game.i18n.translations) {
+    try {
+      const languages = FVTT_PLUGIN.isSystem
+        ? game.system.languages
+        : game.modules.get(FVTT_PLUGIN.id)?.languages
+      if (!languages) {
+        console.warn(
+          'Vite | Got a HMR request to reload languages, however no languages were found.',
+        )
+        return
+      }
+      const langEntry = languages.find(l => l.lang === lang)
+      if (!langEntry) {
+        console.warn('Vite | Got an HMR request for an undefined language')
+        return
+      }
+
+      const url = langEntry.path
+      const resp = await fetch(url)
+      if (!resp.ok) throw new Error('Failed to fetch language file!')
+
+      const json = await resp.json()
+
+      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)
+    }
+  }
+
+  import.meta.hot.on('foundryvtt-language-update', async () => {
+    const currentLang = game.i18n.lang
+    const promises = []
+    if (currentLang !== 'en') {
+      promises.push(hmrLanguage('en', game.i18n._fallback))
+    }
+    promises.push(hmrLanguage(currentLang))
+    await Promise.all(promises)
+    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({ buildPacks = true } = {}) {
+	context.env = await loadEnvironment();
+	return {
+		name: "vite-plugin-fvtt",
+		async config(config) {
+			context.manifest = await loadManifest(config) ?? void 0;
+			return createPartialViteConfig(config);
+		},
+		configResolved(config) {
+			context.config = config;
+		},
+		async generateBundle() {
+			for (const file of ["system.json", "module.json"]) {
+				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, void 0, 2)
+					});
+				}
+			}
+			const languages = context.manifest?.languages ?? [];
+			if (languages.length > 0) for (const language of languages) {
+				if (await getPublicDirectoryFile(language.path)) continue;
+				getLocalLanguageFiles(language.lang).then((langFiles) => {
+					for (const file of langFiles) this.addWatchFile(file);
+				});
+				const languageData = transform(await loadLanguage(language.lang));
+				this.emitFile({
+					type: "asset",
+					fileName: path.join(language.path),
+					source: JSON.stringify(languageData, void 0, 2)
+				});
+			}
+		},
+		async writeBundle() {
+			if (buildPacks) await compileManifestPacks();
+		},
+		closeBundle() {
+			if ((context.manifest?.languages ?? []).length > 0) validator();
+		},
+		load(id) {
+			const config = context.config;
+			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: setupDevelopmentServer
+	};
+}
+
+//#endregion
+export { foundryVTTPlugin as default };