@studiokloek/vite-config 0.13.1 → 0.14.0

package/dist/commands-ujEjJD4C.js

@@ -0,0 +1,862 @@
+import { build, createServer, isCSSRequest, normalizePath } from "vite";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { svelte, vitePreprocess } from "@sveltejs/vite-plugin-svelte";
+import { mkdir, opendir, readFile, rm, writeFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { kloekAssets, resolveConfig } from "@studiokloek/vite-assets-plugin";
+import os from "node:os";
+import Handlebars from "handlebars";
+import legacyPlugin from "@vitejs/plugin-legacy";
+import { visualizer } from "rollup-plugin-visualizer";
+import { minify } from "html-minifier-next";
+import sharp from "sharp";
+import checker from "vite-plugin-checker";
+import fullReload from "vite-plugin-full-reload";
+import mkcert from "vite-plugin-mkcert";
+import filenamify from "filenamify";
+import { zip } from "zip-a-folder";
+//#region src/core/game.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Legt `game` per sectie over `generic` heen; secties die maar aan één kant bestaan blijven behouden. */
+function mergeGameSettings(generic, game) {
+	const merged = { ...generic };
+	for (const [key, value] of Object.entries(game)) {
+		const base = merged[key];
+		merged[key] = isRecord(base) && isRecord(value) ? {
+			...base,
+			...value
+		} : value;
+	}
+	return merged;
+}
+function parseGamesSettings(settings, version) {
+	const games = {};
+	for (const game of settings.games) {
+		const merged = mergeGameSettings(settings.generic, game);
+		const pageId = merged.info.page ?? merged.info.id ?? "unknown";
+		merged.info = {
+			...merged.info,
+			page: pageId,
+			version: merged.info.version ?? version
+		};
+		games[pageId] = merged;
+	}
+	return {
+		development: settings.generic,
+		games
+	};
+}
+/** De pagina die de dev-server opent: de enige game, of anders het overzicht. */
+function getPageToServe(basePath, serveParams, games) {
+	const pageIds = Object.keys(games);
+	const page = pageIds.length === 1 ? pageIds[0] : "development";
+	return path.posix.join(basePath, `${page}.html${serveParams}`);
+}
+/** Het pagina-id uit een url (`/sub/verdwaald.html?debug` → `verdwaald`), of `''` voor iets anders dan html. */
+function getPageIdFromUrl(url) {
+	if (!url) return "";
+	let pathname;
+	try {
+		pathname = new URL(url, "https://studiokloek.nl").pathname;
+	} catch {
+		return "";
+	}
+	if (!pathname.endsWith(".html")) return "";
+	return path.posix.basename(pathname, ".html");
+}
+//#endregion
+//#region src/config/schema.ts
+/**
+* De game-secties zijn vrije template-data voor handlebars en de manifest; alleen de velden die
+* vite-config zelf gebruikt, krijgen een type. Andere velden blijven gewoon behouden.
+*/
+const gameSettingsSchema = z.looseObject({
+	info: z.looseObject({
+		id: z.string().optional(),
+		page: z.string().optional(),
+		version: z.string().optional(),
+		client: z.string().optional(),
+		year: z.union([z.string(), z.number()]).optional()
+	}).prefault({}),
+	meta: z.looseObject({
+		title: z.string().optional(),
+		description: z.string().optional(),
+		apptitle: z.string().optional()
+	}).prefault({}),
+	options: z.looseObject({
+		backgroundColor: z.string().optional(),
+		orientation: z.string().optional(),
+		fullscreen: z.string().optional()
+	}).prefault({})
+});
+const settingsSchema = z.strictObject({
+	/** Instellingen die voor iedere game gelden. */
+	generic: gameSettingsSchema.prefault({}),
+	/** Per game; wordt per sectie over `generic` heen gelegd. */
+	games: z.array(gameSettingsSchema).default([])
+});
+const devSchema = z.strictObject({
+	/** Query-string achter de pagina die bij het starten geopend wordt. */
+	serveParams: z.string().default(""),
+	/** Ook bij wijzigingen in `.svelte`-bestanden de hele pagina herladen. */
+	fullReloadSvelte: z.boolean().default(true),
+	cors: z.boolean().default(true),
+	/** Lokaal certificaat via mkcert. */
+	https: z.boolean().default(true)
+});
+const imageQualitySchema = z.strictObject({
+	jpeg: z.number().min(0).max(100).default(80),
+	/** Minimale en maximale kwaliteit (0–1); de maximale wordt gebruikt. */
+	png: z.tuple([z.number().min(0).max(1), z.number().min(0).max(1)]).default([.5, .7])
+});
+const buildSchema = z.strictObject({
+	basePath: z.string().default("/"),
+	/** Extra bundels voor oudere browsers via `@vitejs/plugin-legacy`. */
+	legacy: z.boolean().default(false),
+	imageQuality: imageQualitySchema.prefault({}),
+	/** Mappen in de build-output waarvan de afbeeldingen niet opnieuw gecomprimeerd worden. */
+	imageExclude: z.array(z.string()).default([
+		"sprites",
+		"sounds",
+		"fonts"
+	]),
+	/** Een webmanifest per game. */
+	manifest: z.boolean().default(false),
+	analyzeBundle: z.boolean().default(false),
+	sourceMaps: z.union([z.boolean(), z.enum(["inline", "hidden"])]).default(false),
+	createZip: z.boolean().default(false),
+	/** Extra patronen voor bestanden die uit de build-output verwijderd worden. */
+	cleanPatterns: z.array(z.string()).default([])
+});
+/** `package.json#vite`. Onbekende keys zijn een fout, zodat een typefout niet stil genegeerd wordt. */
+const viteSchema = z.strictObject({
+	dev: devSchema.prefault({}),
+	build: buildSchema.prefault({}),
+	/** Extra packages die maar één keer in de bundel mogen voorkomen. */
+	dedupe: z.array(z.string()).default([])
+});
+/** De delen van `package.json` die vite-config leest; de rest van het bestand blijft buiten beschouwing. */
+const packageSchema = z.looseObject({
+	name: z.string().default("project"),
+	version: z.string().default("0.0.0"),
+	description: z.string().default(""),
+	browserslist: z.union([z.string(), z.array(z.string())]).optional(),
+	vite: viteSchema.prefault({}),
+	settings: settingsSchema.prefault({}),
+	kloekAssets: z.record(z.string(), z.unknown()).optional()
+});
+function parsePackageConfig(input, file = "package.json") {
+	const result = packageSchema.safeParse(input ?? {});
+	if (!result.success) {
+		const issues = result.error.issues.map((issue) => `  ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+		throw new TypeError(`Invalid config in ${file}:\n${issues}`);
+	}
+	return result.data;
+}
+//#endregion
+//#region src/config/load.ts
+/** Leest en valideert `package.json` van het project in `cwd`. */
+function loadProject(cwd = process.cwd()) {
+	const root = normalizePath(path.resolve(cwd));
+	const file = path.join(root, "package.json");
+	let data;
+	try {
+		data = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		throw new Error(`vite-config: kan ${file} niet lezen`, { cause: error });
+	}
+	const config = parsePackageConfig(data, file);
+	return {
+		cwd: root,
+		sourceDirectory: path.join(root, "source"),
+		outputDirectory: path.join(root, "public"),
+		package: config,
+		...parseGamesSettings(config.settings, config.version)
+	};
+}
+//#endregion
+//#region src/core/fs.ts
+/** Loopt een map recursief door zonder symlinks te volgen, en levert alleen bestanden op. */
+async function* walkFiles(directory) {
+	let entries;
+	try {
+		entries = await opendir(directory);
+	} catch {
+		return;
+	}
+	for await (const entry of entries) {
+		const fullPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) yield* walkFiles(fullPath);
+		else if (entry.isFile()) yield fullPath;
+	}
+}
+/** `filePath` relatief t.o.v. `directory`, altijd met `/` als scheidingsteken. */
+function relativePosix(directory, filePath) {
+	return path.relative(directory, filePath).split(path.sep).join("/");
+}
+let packageRoot;
+/**
+* De root van dit package, gevonden vanaf deze module. Werkt zowel vanuit `dist/` als vanuit
+* `src/` (tests), zodat meegeleverde bestanden als `partials/` zonder kopieerstap te vinden zijn.
+*/
+function packageDirectory(...segments) {
+	if (packageRoot === void 0) {
+		let current = path.dirname(fileURLToPath(import.meta.url));
+		while (!existsSync(path.join(current, "package.json"))) {
+			const parent = path.dirname(current);
+			if (parent === current) throw new Error("vite-config: kan de package-root niet vinden");
+			current = parent;
+		}
+		packageRoot = current;
+	}
+	return path.join(packageRoot, ...segments);
+}
+//#endregion
+//#region src/plugins/assets.ts
+/**
+* De config voor de assets-plugin met absolute paden. Vite's root is `source/`, maar de paden in
+* `package.json#kloekAssets` gelden (net als bij de `kloek-assets` CLI) vanaf de projectmap.
+*/
+async function resolveAssetsConfig(project) {
+	const config = project.package.kloekAssets;
+	if (config === void 0) return;
+	const resolved = await resolveConfig(config, { root: project.cwd });
+	return {
+		...config,
+		entry: resolved.entryDirectory,
+		output: {
+			...config.output,
+			directory: resolved.outputDirectory
+		},
+		scriptDirectory: resolved.scriptDirectory,
+		cacheDirectory: resolved.cacheDirectory
+	};
+}
+/** De assets-plugin, alleen als het project een `kloekAssets`-config in package.json heeft. */
+async function assetsPlugins(project) {
+	const config = await resolveAssetsConfig(project);
+	return config === void 0 ? [] : [kloekAssets(config)];
+}
+//#endregion
+//#region src/plugins/lib/handlebars/partials.ts
+const VALID_EXTENSIONS = /* @__PURE__ */ new Set([".html", ".hbs"]);
+/**
+* De partial-naam voor een bestand: het pad binnen de partials-map zonder extensie
+* (`header/production.hbs` → `header/production`), of `undefined` als het geen partial is.
+*/
+function partialName(directories, file) {
+	const extension = path.extname(file);
+	if (!VALID_EXTENSIONS.has(extension)) return;
+	for (const directory of directories) {
+		const relative = relativePosix(directory, file);
+		if (!relative.startsWith("../") && !path.isAbsolute(relative)) return relative.slice(0, -extension.length);
+	}
+}
+/** Registreert alle partials; bij dubbele namen wint de laatste map (die van het project). */
+async function registerPartials(handlebars, directories) {
+	for (const directory of directories) for await (const file of walkFiles(directory)) {
+		const name = partialName([directory], file);
+		if (name !== void 0) handlebars.registerPartial(name, await readFile(file, "utf8"));
+	}
+}
+const helpers = {
+	json: (object, indent) => JSON.stringify(object, void 0, typeof indent === "number" ? indent : 0),
+	concat: (...values) => values.slice(0, -1).join(""),
+	eq: (a, b) => a === b,
+	neq: (a, b) => a !== b,
+	isdefined: (value) => value !== void 0
+};
+//#endregion
+//#region src/plugins/lib/handlebars/handlebars-plugin.ts
+/** Rendert iedere html-pagina als handlebars-template, vóórdat Vite hem verder verwerkt. */
+function handlebarsPlugin(options) {
+	const handlebars = Handlebars.create();
+	let partialsLoaded;
+	handlebars.registerHelper({
+		...helpers,
+		"resolve-root"(file) {
+			const resolvedPath = normalizePath(path.resolve(options.root, file));
+			return os.platform() === "win32" ? `/${resolvedPath}` : resolvedPath;
+		}
+	});
+	return {
+		name: "vite-plugin-kloek-handlebars",
+		async hotUpdate({ file, type }) {
+			const name = partialName(options.partialDirectories, file);
+			if (name === void 0) return;
+			if (type === "delete") handlebars.unregisterPartial(name);
+			else handlebars.registerPartial(name, await readFile(file, "utf8"));
+			if (this.environment.name === "client") this.environment.hot.send({ type: "full-reload" });
+			return [];
+		},
+		transformIndexHtml: {
+			order: "pre",
+			async handler(html, context) {
+				partialsLoaded ??= registerPartials(handlebars, options.partialDirectories);
+				await partialsLoaded;
+				const pageId = getPageIdFromUrl(normalizePath(context.path));
+				return handlebars.compile(html)(pageId ? options.context(pageId) : {});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/lib/html-plugin.ts
+const PAGE_TEMPLATE = "{{> game data=data}}";
+const DEVELOPMENT_TEMPLATE = "{{> development data=data}}";
+/**
+* Levert per game een html-pagina die door handlebars (`game.hbs`) ingevuld wordt. Bij een build zijn
+* de pagina's virtuele modules, dus er komen geen tijdelijke bestanden in `source/`.
+*/
+function htmlPlugin(project) {
+	const pages = new Set(Object.keys(project.games).map((pageId) => normalizePath(path.join(project.sourceDirectory, `${pageId}.html`))));
+	return {
+		name: "vite-plugin-kloek-html",
+		enforce: "pre",
+		resolveId(source) {
+			const id = normalizePath(source);
+			return pages.has(id) ? id : void 0;
+		},
+		load(id) {
+			return pages.has(id) ? PAGE_TEMPLATE : void 0;
+		},
+		configureServer(server) {
+			return () => {
+				server.middlewares.use(async (request, response, next) => {
+					const url = request.originalUrl ?? "";
+					const pageId = getPageIdFromUrl(url);
+					let template;
+					if (pageId === "development") template = DEVELOPMENT_TEMPLATE;
+					else if (pageId in project.games) template = PAGE_TEMPLATE;
+					if (template === void 0) {
+						next();
+						return;
+					}
+					try {
+						const html = await server.transformIndexHtml(url, template, url);
+						response.setHeader("Content-Type", "text/html");
+						response.end(html);
+					} catch (error) {
+						next(error);
+					}
+				});
+			};
+		}
+	};
+}
+//#endregion
+//#region src/plugins/base.ts
+async function basePlugins(project, environment) {
+	const env = {
+		command: environment.command,
+		mode: environment.mode
+	};
+	return [
+		htmlPlugin(project),
+		svelte({
+			preprocess: vitePreprocess(),
+			onwarn(warning, handler) {
+				if (warning.code.startsWith("a11y")) return;
+				handler(warning);
+			}
+		}),
+		handlebarsPlugin({
+			partialDirectories: [packageDirectory("partials"), path.join(project.sourceDirectory, "partials")],
+			root: project.sourceDirectory,
+			context(pageId) {
+				if (pageId === "development") return {
+					env,
+					data: project.development,
+					games: project.games
+				};
+				return {
+					env,
+					data: project.games[pageId] ?? {}
+				};
+			}
+		}),
+		...await assetsPlugins(project)
+	];
+}
+//#endregion
+//#region src/plugins/lib/banner-plugin.ts
+/** De tekst als commentaarblok, zoals bovenaan iedere js- en css-file. */
+function renderBanner(content) {
+	return `/**\n${content.split("\n").map((line) => line ? ` * ${line}` : " *").join("\n")}\n */\n`;
+}
+/** Zet een banner bovenaan de gegenereerde js (na minificatie, met kloppende sourcemaps) en css. */
+function bannerPlugin(content) {
+	const banner = renderBanner(content);
+	return {
+		name: "vite-plugin-kloek-banner",
+		apply: "build",
+		config() {
+			return { build: { rolldownOptions: { output: { postBanner: banner } } } };
+		},
+		generateBundle(_, bundle) {
+			for (const file of Object.values(bundle)) if (file.type === "asset" && file.fileName.endsWith(".css")) file.source = `${banner}${typeof file.source === "string" ? file.source : new TextDecoder().decode(file.source)}`;
+		}
+	};
+}
+//#endregion
+//#region src/plugins/lib/clean-plugin.ts
+const DEFAULT_PATTERNS = [
+	"**/.DS_Store",
+	"**/._*",
+	"**/Thumbs.db",
+	"**/desktop.ini",
+	"**/.gitignore",
+	"**/.gitkeep"
+];
+function patternToRegExp(pattern) {
+	let source = pattern;
+	let matchInSubdirectories = false;
+	if (source.startsWith("**/")) {
+		matchInSubdirectories = true;
+		source = source.slice(3);
+	}
+	const body = source.replaceAll(/[.*+?^${}()|[\]\\]/g, (character) => character === "*" ? "[^/]*" : `\\${character}`);
+	return new RegExp(matchInSubdirectories ? `(?:^|/)${body}$` : `^${body}$`);
+}
+function cleanPlugin(patterns = []) {
+	const expressions = [...DEFAULT_PATTERNS, ...patterns].map((pattern) => patternToRegExp(pattern));
+	let outDir = "";
+	return {
+		name: "vite-plugin-kloek-clean",
+		enforce: "post",
+		apply: "build",
+		configResolved(config) {
+			outDir = path.resolve(config.root, config.build.outDir);
+		},
+		async closeBundle() {
+			const actions = [];
+			for await (const filePath of walkFiles(outDir)) {
+				const relativePath = relativePosix(outDir, filePath);
+				if (expressions.some((expression) => expression.test(relativePath))) actions.push(rm(filePath).catch(() => void 0));
+			}
+			await Promise.all(actions);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/lib/html-minify-plugin.ts
+const OPTIONS = {
+	collapseWhitespace: true,
+	keepClosingSlash: true,
+	removeComments: true,
+	removeRedundantAttributes: true,
+	removeDefaultTypeAttributes: true,
+	useShortDoctype: true,
+	minifyCSS: true
+};
+/** Minificeert de html-pagina's in de build-output. */
+function htmlMinifyPlugin() {
+	return {
+		name: "vite-plugin-kloek-html-minify",
+		enforce: "post",
+		apply: "build",
+		async generateBundle(_, bundle) {
+			for (const file of Object.values(bundle)) if (file.type === "asset" && file.fileName.endsWith(".html") && typeof file.source === "string") file.source = await minify(file.source, OPTIONS);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/lib/image-plugin.ts
+const EXTENSIONS = /* @__PURE__ */ new Set([
+	".png",
+	".jpg",
+	".jpeg"
+]);
+/** Comprimeert één afbeelding; geeft `undefined` als het resultaat niet kleiner is. */
+async function optimizeImage(input, extension, quality) {
+	const image = sharp(input);
+	const output = extension === ".png" ? await image.png({
+		palette: true,
+		quality: Math.round(Math.max(...quality.png) * 100),
+		effort: 8
+	}).toBuffer() : await image.jpeg({
+		quality: quality.jpeg,
+		mozjpeg: true
+	}).toBuffer();
+	return output.length < input.length ? output : void 0;
+}
+function formatBytes(bytes) {
+	return bytes >= 1048576 ? `${(bytes / 1024 / 1024).toFixed(1)} MB` : `${Math.round(bytes / 1024)} kB`;
+}
+/**
+* Comprimeert na een productie-build de losse png/jpg's in de output. Sprites, geluid en fonts komen
+* al gecomprimeerd uit de assets-plugin en worden overgeslagen.
+*/
+function imagePlugin(options) {
+	const exclude = new Set(options.exclude);
+	let outDir = "";
+	let enabled = false;
+	let logger = console;
+	return {
+		name: "vite-plugin-kloek-image",
+		enforce: "post",
+		apply: "build",
+		configResolved(config) {
+			outDir = path.resolve(config.root, config.build.outDir);
+			enabled = config.mode === "production";
+			logger = config.logger;
+		},
+		async closeBundle() {
+			if (!enabled) return;
+			const files = [];
+			for await (const file of walkFiles(outDir)) {
+				const [firstSegment] = relativePosix(outDir, file).split("/");
+				if (EXTENSIONS.has(path.extname(file).toLowerCase()) && !exclude.has(firstSegment ?? "")) files.push(file);
+			}
+			let before = 0;
+			let saved = 0;
+			const queue = [...files];
+			const workers = Array.from({ length: Math.min(os.availableParallelism(), 4) }, async () => {
+				for (let file = queue.shift(); file !== void 0; file = queue.shift()) {
+					const input = await readFile(file);
+					const output = await optimizeImage(input, path.extname(file).toLowerCase(), options.quality);
+					before += input.length;
+					if (output !== void 0) {
+						saved += input.length - output.length;
+						await writeFile(file, output);
+					}
+				}
+			});
+			await Promise.all(workers);
+			if (files.length > 0) logger.info(`kloek-image: ${files.length} afbeeldingen, ${formatBytes(saved)} kleiner (${formatBytes(before)} → ${formatBytes(before - saved)})`);
+		}
+	};
+}
+//#endregion
+//#region src/plugins/lib/manifest-plugin.ts
+function renderGameManifest(pageId, settings, base) {
+	const manifest = {
+		short_name: `${settings.meta.apptitle ?? ""}`,
+		name: `${settings.meta.title ?? ""}`,
+		description: `${settings.meta.description ?? ""}`,
+		scope: `${base}${pageId}.html`,
+		start_url: `${base}${pageId}.html`,
+		display: "fullscreen",
+		orientation: `${settings.options.orientation ?? "landscape"}`,
+		icons: [{
+			src: `${base}meta/${settings.info.id}/icons/chrome-touch-icon-192x192.png`,
+			type: "image/png",
+			sizes: "192x192"
+		}, {
+			src: `${base}meta/${settings.info.id}/icons/icon.png`,
+			type: "image/png",
+			sizes: "1024x1024"
+		}],
+		background_color: `${settings.options.backgroundColor ?? ""}`,
+		theme_color: `${settings.options.backgroundColor ?? ""}`
+	};
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/** Schrijft voor iedere game een `<page>.webmanifest`. */
+function manifestPlugin(games) {
+	let base = "/";
+	return {
+		name: "vite-plugin-kloek-manifest",
+		enforce: "post",
+		apply: "build",
+		configResolved(config) {
+			base = config.base;
+		},
+		generateBundle() {
+			for (const [pageId, settings] of Object.entries(games)) this.emitFile({
+				type: "asset",
+				fileName: `${pageId}.webmanifest`,
+				source: renderGameManifest(pageId, settings, base)
+			});
+		}
+	};
+}
+//#endregion
+//#region src/plugins/build.ts
+const BANNER = `. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
+
+         __                             ,      _            _
+        /  )              |  o         /|   / | |          | |
+        \\__ _|_         __|      __     |__/  | |  __   _  | |
+           \\ |  |   |  /  |  |  /  \\_   | \\   |/  /  \\_|/  |/_)
+       (___/ |_/ \\_/|_/\\_/|_/|_/\\__/    |  \\_/|__/\\__/ |__/| \\_/
+
+        Concept, ontwerp & ontwikkeling
+        https://studiokloek.nl
+
+        Studio Kloek ❤ PixiJS, GSAP & howler.js
+
+    . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .`;
+function buildPlugins(project) {
+	const build = project.package.vite.build;
+	const plugins = [];
+	if (build.legacy) plugins.push(legacyPlugin({ targets: project.package.browserslist ?? "defaults" }));
+	plugins.push(imagePlugin({
+		quality: build.imageQuality,
+		exclude: build.imageExclude
+	}), htmlMinifyPlugin(), bannerPlugin(BANNER));
+	if (build.manifest) plugins.push(manifestPlugin(project.games));
+	plugins.push(cleanPlugin(build.cleanPatterns));
+	if (build.analyzeBundle) plugins.push(visualizer({
+		template: "treemap",
+		open: true,
+		gzipSize: true,
+		filename: "bundle-analyse.html"
+	}));
+	return plugins;
+}
+//#endregion
+//#region src/plugins/serve.ts
+function servePlugins(project) {
+	const { dev } = project.package.vite;
+	const fullReloadPaths = ["script/**/*.ts"];
+	if (dev.fullReloadSvelte) fullReloadPaths.push("svelte/**/*.svelte");
+	const plugins = [fullReload(fullReloadPaths, {
+		root: project.sourceDirectory,
+		always: true
+	})];
+	if (dev.https) plugins.push(mkcert());
+	plugins.push(checker({
+		root: project.cwd,
+		typescript: { root: project.cwd },
+		biome: true
+	}));
+	return plugins;
+}
+//#endregion
+//#region src/core/chunks.ts
+const VENDOR_CHUNKS = [
+	{
+		match: "lodash-decorators",
+		chunk: "lodash-decorators"
+	},
+	{
+		match: "lodash",
+		chunk: "lodash"
+	},
+	{
+		match: "date-fns-tz",
+		chunk: "date-fns"
+	},
+	{
+		match: "date-fns",
+		chunk: "date-fns"
+	},
+	{
+		match: "svelte",
+		chunk: "svelte"
+	},
+	{
+		match: "pixi-spine",
+		chunk: "pixi"
+	},
+	{
+		match: "@pixi-spine",
+		chunk: "pixi"
+	},
+	{
+		match: "@pixi",
+		chunk: "pixi"
+	},
+	{
+		match: "pixi",
+		chunk: "pixi"
+	},
+	{
+		match: "@firebase",
+		chunk: "firebase"
+	},
+	{
+		match: "@studiokloek",
+		chunk: "studiokloek"
+	},
+	{
+		match: "capacitor",
+		chunk: "capacitor"
+	},
+	{
+		match: "@capacitor",
+		chunk: "capacitor"
+	},
+	{
+		match: "gsap",
+		chunk: "gsap"
+	},
+	{
+		match: "howler",
+		chunk: "howler"
+	},
+	{
+		match: "firebase",
+		chunk: "firebase"
+	},
+	{
+		match: "overmind",
+		chunk: "overmind"
+	}
+];
+/** De package-naam uit een module-id, via het laatste `node_modules/`-segment (werkt ook met pnpm). */
+function packageNameFromId(id) {
+	const normalized = id.replaceAll("\\", "/");
+	const index = normalized.lastIndexOf("/node_modules/");
+	if (index === -1) return;
+	const [first, second] = normalized.slice(index + 14).split("/");
+	if (!first) return;
+	return first.startsWith("@") && second ? `${first}/${second}` : first;
+}
+function matchesPackage(name, match) {
+	if (match.startsWith("@")) return name.startsWith(`${match}/`);
+	if (name === match) return true;
+	const charAfter = name[match.length];
+	return name.startsWith(match) && (charAfter === "-" || charAfter === ".");
+}
+/** De vendor-chunk voor een module, of `undefined` voor eigen code en css. */
+function vendorChunkName(id) {
+	if (isCSSRequest(id)) return;
+	const name = packageNameFromId(id);
+	if (name === void 0) return;
+	return VENDOR_CHUNKS.find((entry) => matchesPackage(name, entry.match))?.chunk ?? "vendor";
+}
+//#endregion
+//#region src/config/build.ts
+function defineBuildConfig(project) {
+	const input = {};
+	for (const pageId of Object.keys(project.games)) input[pageId] = path.join(project.sourceDirectory, `${pageId}.html`);
+	return {
+		reportCompressedSize: true,
+		chunkSizeWarningLimit: 2e3,
+		outDir: project.outputDirectory,
+		emptyOutDir: true,
+		assetsDir: "generated",
+		sourcemap: project.package.vite.build.sourceMaps,
+		rolldownOptions: {
+			input,
+			output: {
+				codeSplitting: { groups: [{
+					debugName: "vendor-chunks",
+					name: (id) => vendorChunkName(id) ?? null
+				}] },
+				comments: { legal: false }
+			}
+		}
+	};
+}
+//#endregion
+//#region src/config/vite.ts
+const DEDUPE = [
+	"@studiokloek/ts-core-lib",
+	"@capacitor/app",
+	"@capacitor/core",
+	"@capacitor/device",
+	"@capacitor/network",
+	"@capacitor/preferences",
+	"@capacitor/splash-screen",
+	"@capacitor/status-bar",
+	"bowser",
+	"date-fns-tz",
+	"date-fns",
+	"error-stack-parser-es",
+	"firebase",
+	"fontfaceobserver",
+	"gsap",
+	"howler",
+	"lodash-decorators",
+	"lodash",
+	"overmind",
+	"pixi-spine",
+	"pixi",
+	"pubsub-js",
+	"random-js",
+	"ress",
+	"slugify",
+	"superagent",
+	"ts-events",
+	"ts-mixer",
+	"tslib"
+];
+/** De volledige Vite-config voor een kloek-project; standaard dat in de huidige map. */
+async function defineKloekViteConfig(environment, project = loadProject()) {
+	const { vite } = project.package;
+	const config = {
+		mode: environment.mode,
+		logLevel: "info",
+		base: vite.build.basePath,
+		root: project.sourceDirectory,
+		envDir: path.join(project.cwd, "env"),
+		envPrefix: ["KLOEK_", "VITE_"],
+		publicDir: "static",
+		resolve: {
+			alias: {
+				"@meta": path.join(project.sourceDirectory, "static", "meta"),
+				"@fonts": path.join(project.sourceDirectory, "static", "fonts")
+			},
+			dedupe: [.../* @__PURE__ */ new Set([...DEDUPE, ...vite.dedupe])],
+			tsconfigPaths: true
+		},
+		css: { preprocessorOptions: { scss: { charset: false } } },
+		plugins: await basePlugins(project, environment)
+	};
+	if (environment.command === "serve") {
+		config.server = {
+			host: true,
+			cors: vite.dev.cors,
+			open: getPageToServe(vite.build.basePath, vite.dev.serveParams, project.games)
+		};
+		config.plugins = [...config.plugins ?? [], ...servePlugins(project)];
+	} else {
+		config.build = defineBuildConfig(project);
+		config.plugins = [...config.plugins ?? [], ...buildPlugins(project)];
+	}
+	return config;
+}
+//#endregion
+//#region src/core/zip.ts
+/** Pakt de build-output in als `zips/<naam>-v<versie>.zip`; geeft het pad van de zip terug. */
+async function addBuildFolderToZip(project) {
+	const destinationDirectory = path.join(project.cwd, "zips");
+	const destinationFile = path.join(destinationDirectory, filenamify(`${project.package.name}-v${project.package.version}.zip`, { replacement: "-" }));
+	await mkdir(destinationDirectory, { recursive: true });
+	await rm(destinationFile, { force: true });
+	await zip(project.outputDirectory, destinationFile);
+	return destinationFile;
+}
+//#endregion
+//#region src/commands.ts
+async function kloekDevelopment(options = {}) {
+	const project = loadProject(options.cwd);
+	const config = await defineKloekViteConfig({
+		command: "serve",
+		mode: options.mode ?? "development"
+	}, project);
+	const server = await createServer({
+		configFile: false,
+		...config
+	});
+	await server.listen();
+	server.printUrls();
+	server.bindCLIShortcuts({ print: true });
+}
+async function kloekBuild(options = {}) {
+	const project = loadProject(options.cwd);
+	const config = await defineKloekViteConfig({
+		command: "build",
+		mode: options.mode ?? "production"
+	}, project);
+	const buildConfig = { ...config.build };
+	if (options.emptyOutDir !== void 0) buildConfig.emptyOutDir = options.emptyOutDir;
+	if (options.sourcemaps !== void 0 || options.inlineSourcemaps) buildConfig.sourcemap = options.sourcemaps ?? true ? options.inlineSourcemaps ? "inline" : true : false;
+	if (options.base !== void 0) config.base = options.base;
+	if (options.logLevel !== void 0) config.logLevel = options.logLevel;
+	await build({
+		configFile: false,
+		...config,
+		build: buildConfig
+	});
+	if (options.createZip ?? project.package.vite.build.createZip) await addBuildFolderToZip(project);
+}
+//#endregion
+export { packageDirectory as a, defineBuildConfig as i, kloekDevelopment as n, loadProject as o, defineKloekViteConfig as r, parsePackageConfig as s, kloekBuild as t };