kirbyup 3.4.1 → 3.5.0

package/README.md

@@ -2,25 +2,26 @@
 
 # kirbyup
 
-[![npm version](https://img.shields.io/npm/v/kirbyup?color=a1b858&label=)](https://www.npmjs.com/package/kirbyup)
-
-The official bundler for Kirby Panel plugins with zero-config usage and built-in HMR.
+The official bundler for Kirby Panel plugins. Zero-config, built-in HMR.
 
 - [✨  Release Notes](https://github.com/johannschopplich/kirbyup/releases)
 - [📖  Read the documentation](https://kirbyup.getkirby.com)
 
 ## Key Features
 
-- 🔄 [Hot module replacement](https://kirbyup.getkirby.com/guide/getting-started.html#development)
-- 🎒 PostCSS support
-- 🧭 Add custom path aliases
-- 🔌 Run actions based on environment variables
-- 🦔 [Extends Vite with `kirbyup.config.js`](https://kirbyup.getkirby.com/guide/config-file)
+- 🔄 [Hot Module Replacement](https://kirbyup.getkirby.com/guide/getting-started.html#development)
+- 🎒 [PostCSS & Sass](https://kirbyup.getkirby.com/guide/postcss)
+- 🧩 [kirbyuse Integration](https://kirbyup.getkirby.com/guide/kirbyuse)
+- 🔌 [Environment Variables](https://kirbyup.getkirby.com/guide/environment-variables)
+- 🦔 [Configuration File](https://kirbyup.getkirby.com/guide/config-file)
+- 🧭 [Path Aliases](https://kirbyup.getkirby.com/guide/path-aliases)
 
 ## Setup
 
 > [!TIP]
-> [📖 Read the documentation](https://kirbyup.getkirby.com)
+> Skip starting from scratch and pick one of the following starters:
+> - [`eslint`](./examples/eslint)
+> - [`unocss`](./examples/unocss)
 
 ```bash
 # pnpm
@@ -28,16 +29,12 @@ pnpm add -D kirbyup
 
 # npm
 npm i -D kirbyup
-```
-
-## Basic Usage
 
-> [!TIP]
-> [📖 Read the documentation](https://kirbyup.getkirby.com) or skip starting from scratch and pick one of the following starters:
-> - [`eslint`](./examples/eslint)
-> - [`tailwindcss`](./examples/tailwindcss)
+# yarn
+yarn add -D kirbyup
+```
 
-Having installed kirbyup, you can add the following scripts as shortcuts to the commands you will use most often:
+After installation, add these scripts to your `package.json`:
 
 ```json
 {
@@ -46,18 +43,18 @@ Having installed kirbyup, you can add the following scripts as shortcuts to the
     "build": "kirbyup src/index.js"
   },
   "devDependencies": {
-    "kirbyup": "^3.4.0"
+    "kirbyup": "^3.5.0"
   }
 }
 ```
 
-## 💻 Development
+## Development
 
 1. Clone this repository
 2. Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
 3. Install dependencies using `pnpm install`
-4. Run `pnpm run dev:prepare`
-5. Start development server using `pnpm run dev`
+4. Build with `pnpm run build`
+5. Run tests with `pnpm test`
 
 ## License
 

package/bin/kirbyup.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 'use strict'
-import('../dist/node/cli.js')
+import('../dist/node/cli.mjs')

package/dist/client/{config.d.ts → config.d.mts}

@@ -1,5 +1,4 @@
-import { UserConfig } from "../node/types.js";
-
+import { r as UserConfig } from "../types-C3c_wslr.mjs";
 //#region src/client/config.d.ts
 declare function defineConfig(config: UserConfig): UserConfig;
 //#endregion

package/dist/client/{config.js → config.mjs}

@@ -2,6 +2,5 @@
 function defineConfig(config) {
 	return config;
 }
-
 //#endregion
-export { defineConfig };
+export { defineConfig };

package/dist/client/plugin.mjs

@@ -0,0 +1,20 @@
+//#region src/client/plugin.ts
+const kirbyup = Object.freeze({ 
+/**
+* Auto-import Kirby Panel components, transformed by
+* kirbyup's glob-import plugin for Vite.
+*
+* @example
+* kirbyup.import('./components/blocks/*.vue')
+*/
+import(glob) {
+	return Object.entries(glob).reduce((accumulator, [path, component]) => {
+		accumulator[getComponentName(path)] = component.default;
+		return accumulator;
+	}, {});
+} });
+function getComponentName(path) {
+	return path.substring(path.lastIndexOf("/") + 1, path.lastIndexOf(".")).toLowerCase();
+}
+//#endregion
+export { kirbyup };

package/dist/node/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/node/{cli-start.js → cli.mjs}

@@ -1,7 +1,5 @@
-import { name, version } from "../package.js";
-import { build, serve } from "./index.js";
+import { a as version, i as name, n as serve, r as handleError, t as build } from "../node-UMSghnjT.mjs";
 import { cac } from "cac";
-
 //#region src/node/cli-start.ts
 async function startCli(cwd = process.cwd(), argv = process.argv) {
 	const cli = cac(name);
@@ -37,6 +35,8 @@ async function startCli(cwd = process.cwd(), argv = process.argv) {
 	cli.parse(argv, { run: false });
 	await cli.runMatchedCommand();
 }
-
 //#endregion
-export { startCli };
+//#region src/node/cli.ts
+startCli().catch(handleError);
+//#endregion
+export {};

package/dist/node/{index.d.ts → index.d.mts}

@@ -1,6 +1,5 @@
-import { BuildOptions, ServeOptions } from "./types.js";
+import { n as ServeOptions, t as BuildOptions } from "../types-C3c_wslr.mjs";
 import { ViteDevServer } from "vite";
-
 //#region src/node/index.d.ts
 declare function build(options: BuildOptions): Promise<void>;
 declare function serve(options: ServeOptions): Promise<ViteDevServer>;

package/dist/node/index.mjs

@@ -0,0 +1,2 @@
+import { n as serve, t as build } from "../node-UMSghnjT.mjs";
+export { build, serve };

package/dist/node-UMSghnjT.mjs

@@ -0,0 +1,470 @@
+import * as fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import vuePlugin from "@vitejs/plugin-vue2";
+import vueJsxPlugin from "@vitejs/plugin-vue2-jsx";
+import { consola } from "consola";
+import { colors } from "consola/utils";
+import { basename, dirname, normalize, relative, resolve } from "pathe";
+import { debounce } from "perfect-debounce";
+import externalGlobals from "rollup-plugin-external-globals";
+import { build, createLogger, createServer, mergeConfig } from "vite";
+import fullReloadPlugin from "vite-plugin-full-reload";
+import * as vueCompilerSfc from "vue/compiler-sfc";
+import { loadConfig } from "c12";
+import postcssrc from "postcss-load-config";
+import MagicString from "magic-string";
+import { stripLiteral } from "strip-literal";
+import { detectPackageManager } from "nypm";
+import { isIP } from "node:net";
+import { Buffer } from "node:buffer";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+//#region package.json
+var name = "kirbyup";
+var version = "3.5.0";
+//#endregion
+//#region src/node/config.ts
+function loadConfig$1(cwd = process.cwd()) {
+	return loadConfig({
+		cwd,
+		name: "kirbyup",
+		rcFile: false,
+		packageJson: false
+	});
+}
+async function resolvePostCSSConfig(cwd) {
+	try {
+		return await postcssrc(void 0, void 0, { stopDir: cwd });
+	} catch (error) {
+		if (!error.message.includes("No PostCSS Config found")) throw error;
+	}
+}
+//#endregion
+//#region src/node/errors.ts
+var PrettyError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = this.constructor.name;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+function handleError(error) {
+	consola.error(error.message);
+	process.exitCode = 1;
+}
+//#endregion
+//#region src/node/plugins/build-cleanup.ts
+function kirbyupBuildCleanupPlugin(options) {
+	let config;
+	let devIndexPath;
+	return {
+		name: "kirbyup:build-cleanup",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			devIndexPath = resolve(config.root, options.outDir, "index.dev.mjs");
+		},
+		writeBundle() {
+			if (fs.existsSync(devIndexPath)) fs.unlinkSync(devIndexPath);
+		}
+	};
+}
+//#endregion
+//#region src/node/plugins/glob-import.ts
+/**
+* Transforms `kirbyup.import(<path>)` to `kirbyup.import(import.meta.glob(<path>, { eager: true }))`.
+*
+* Must run before Vite's own `import.meta.glob` plugin (also `enforce: 'pre'`),
+* otherwise the emitted call is never expanded.
+*/
+function kirbyupGlobImportPlugin() {
+	let config;
+	return {
+		name: "kirbyup:glob-import",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		transform(code) {
+			if (!code.includes("kirbyup.import")) return;
+			const kirbyupImportRE = /\bkirbyup\.import\s*\(\s*('[^']+'|"[^"]+"|`[^`]+`)\s*\)/dg;
+			const cleanCode = stripLiteral(code);
+			let s;
+			for (const match of cleanCode.matchAll(kirbyupImportRE)) {
+				const { 0: exp, index } = match;
+				const [argStart, argEnd] = match.indices[1];
+				const rawPath = code.slice(argStart, argEnd);
+				if (!s) s = new MagicString(code);
+				s.overwrite(index, index + exp.length, `kirbyup.import(import.meta.glob(${rawPath}, { eager: true }))`);
+			}
+			if (s) return {
+				code: s.toString(),
+				map: config.build.sourcemap ? s.generateMap({ hires: true }) : void 0
+			};
+		}
+	};
+}
+//#endregion
+//#region src/node/utils/server.ts
+function resolveOriginFromServerOptions(serverOptions, port, fallbackHostname) {
+	const protocol = serverOptions?.https && (typeof serverOptions.https === "boolean" || Object.keys(serverOptions.https).length > 0) ? "https" : "http";
+	const configuredHost = normalizeHost(serverOptions?.host);
+	return `${protocol}://${formatHostname(configuredHost || fallbackHostname || "localhost")}${(configuredHost ? hostIncludesPort(configuredHost) : false) || !needsExplicitPort(protocol, port) ? "" : `:${port}`}`;
+}
+function ensureTrailingSlash(url) {
+	return url.endsWith("/") ? url : `${url}/`;
+}
+function normalizeHost(host) {
+	if (host === false || host === void 0) return;
+	if (host === true) return "0.0.0.0";
+	return host;
+}
+function formatHostname(host) {
+	if (!host) return "localhost";
+	if (host.startsWith("[") && host.endsWith("]")) return host;
+	return isIP(host) === 6 ? `[${host}]` : host;
+}
+function hostIncludesPort(host) {
+	if (host.startsWith("[")) {
+		const closingIndex = host.indexOf("]");
+		return closingIndex > -1 && host.slice(closingIndex + 1).startsWith(":");
+	}
+	if (isIP(host) === 6) return false;
+	return host.includes(":");
+}
+function needsExplicitPort(protocol, port) {
+	if (protocol === "http") return port !== 80;
+	return port !== 443;
+}
+function isHmrRuntimeId(id) {
+	return id === "\0plugin-vue2:hmr-runtime" || id === "plugin-vue2-jsx:hmr-runtime";
+}
+/**
+* This code is injected into the HMR runtime of plugin-vue2(-jsx).
+*
+* All `.vue` components register themselves once with the HMR runtime, so their exported
+* component definitions can be stored in a map, alongside the rendered component instances
+* that are based off this definition. When a module is updated, the runtime applies all
+* changes from the updated module to the stored definition, then re-renders the instances.
+*
+* ```js
+* {
+*   [id]: { options: ComponentDefinition, instances: [...] }
+* }
+* ```
+*
+* However, in some cases (sections and blocks) Kirby does not actually register the
+* object that is exported from a `.vue` file (and stored as definition) as component,
+* instead it creates a new object and merges the definition from the `.vue` file in:
+* https://github.com/getkirby/kirby/blob/main/panel/public/js/plugins.js#L22-L25
+* After changes, the runtime updates the definition and re-renders the instances, but since
+* they are derived from the object created by Kirby, not the stored definition, nothing happens.
+* To fix that, we wrap `rerender()` and `reload()` so that before applying the updates, we first check
+* if the updated definition belongs to a component added by a Kirby plugin. To do so, we can check
+* whether the `__file` (added by plugin-vue2) or `__hmrId` (added by plugin-vue2-jsx) properties of the
+* updated module and the plugin component match. If so, we look up the component definition that is
+* _actually_ used by component instances rendered on the page (`window.panel.app.$options.components`)
+* and if it differs from the one stored in the HMR runtime's map, we updates the map's reference.
+*
+* We also check the component name and add a `$_isSection` flag if it's `k-something-section`, because
+* section components are hard to detect and need special treatment in `$_applyKirbyModifications`.
+*
+* `$_applyKirbyModifications`:
+*
+* Kirby modifies component definitions before registering components.
+* This includes adding the section mixin to section components,
+* giving templates priority over render functions if both exist
+* and resolving component names in `extends` to their definition object:
+* https://github.com/getkirby/kirby/blob/2965c3124e3b141072a2d46c798a327dda710060/panel/src/panel/plugins.js
+* When a module is reloaded, Vue receives a fresh component definition that is
+* missing these modifications. We need to re-apply them, else the runtime will
+* prune them when patching the stored definition to match the newer one.
+*
+* The call to `$_applyKirbyModifications()` is injected into `__VUE_HMR_RUNTIME__.reload()`
+* at the appropriate position using a RegExp in the Vite plugin's transform method.
+*/
+const __INJECTED_HMR_CODE__ = `
+/** - injected by kirbyup - */
+for (const methodName of ['rerender', 'reload']) {
+  const original = __VUE_HMR_RUNTIME__[methodName]
+
+  __VUE_HMR_RUNTIME__[methodName] = function (id, updatedDef) {
+    const key = updatedDef?.__file ? '__file' : updatedDef?.__hmrId ? '__hmrId' : null
+
+    if (key) {
+      const pluginComponents = window.panel.plugins.components
+      // const usedComponentDefs = window.panel.app.$options.components
+      const usedComponentDefs = window.panel.app._vnode.componentInstance.$options.components // #33
+
+      for (const componentName in pluginComponents) {
+        if (updatedDef[key] === pluginComponents[componentName][key]) {
+          const usedDefinition = usedComponentDefs[componentName].options
+
+          if (map[id].options !== usedDefinition)
+            map[id].options = usedDefinition
+
+          if (typeof map[id].options.$_isSection !== 'boolean')
+            map[id].options.$_isSection = /^k-.*-section$/.test(componentName)
+
+          break
+        }
+      }
+    }
+
+    return original.apply(this, arguments)
+  }
+}
+
+function $_applyKirbyModifications(activeDef, newDef) {
+  const usedComponentDefs = window.panel.app.$options.components
+
+  if (newDef.template)
+    newDef.render = null
+
+  if (activeDef.$_isSection)
+    newDef.$_isSection = true
+  if (newDef.$_isSection && !newDef.mixins?.[0]?.methods?.load)
+    newDef.mixins = [activeDef.mixins[0], ...(newDef.mixins || [])]
+
+  if (typeof newDef.extends === 'string') {
+    if (newDef.extends === activeDef.extends?.options?.name) {
+      newDef.extends = activeDef.extends
+    }
+    else if (usedComponentDefs[newDef.extends]) {
+      newDef.extends = usedComponentDefs[newDef.extends].extend({
+        options: newDef,
+        components: { ...usedComponentDefs, ...(newDef.components || {}) },
+      })
+    }
+    else { newDef.extends = null }
+  }
+}
+/** -- */
+`;
+//#endregion
+//#region src/node/plugins/hmr.ts
+function kirbyupHmrPlugin(options) {
+	let config;
+	let entry;
+	let devIndexPath;
+	return {
+		name: "kirbyup:hmr",
+		apply: "serve",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+			entry = resolve(config.root, options.entry);
+			devIndexPath = resolve(config.root, options.outDir ?? "", "index.dev.mjs");
+		},
+		transform(code, id) {
+			if (isHmrRuntimeId(id)) return code.replace(/^.*=\s*record\.Ctor\.super\.extend\(options\)/m, "$_applyKirbyModifications(record.Ctor.options, options) // injected by kirbyup\n$&") + __INJECTED_HMR_CODE__;
+		},
+		configureServer(server) {
+			if (!server.httpServer) return;
+			server.httpServer.once("listening", async () => {
+				const entryPath = entry.replace(`${config.root}/`, "");
+				const baseUrl = getDevBaseUrl(server, config);
+				const entryUrl = new URL(entryPath, baseUrl).href;
+				const pm = await detectPackageManager(config.root);
+				await fsp.writeFile(devIndexPath, getViteProxyModule(entryUrl, pm));
+			});
+		},
+		async closeBundle() {
+			await fsp.rm(devIndexPath, { force: true });
+		}
+	};
+}
+/**
+* Proxy the JS file to "forward" the plugin script loaded by Kirby to the Vite server
+*/
+function getViteProxyModule(entryUrl, packageManager) {
+	const pm = packageManager?.name || "npm";
+	return `
+try {
+  await import("${entryUrl}");
+} catch (error) {
+  console.error(
+    "[kirbyup] Couldn't connect to the development server at ${entryUrl}. Run \`${pm} run serve\` to start Vite or build the plugin with \`${pm} run build\` so Kirby uses the production version."
+  );
+  throw error;
+}
+`.trimStart();
+}
+function getDevBaseUrl(server, config) {
+	const { address, port } = server.httpServer.address();
+	const normalizedOrigin = ensureTrailingSlash(config.server?.origin ?? server.resolvedUrls?.local?.[0] ?? server.resolvedUrls?.network?.[0] ?? resolveOriginFromServerOptions(config.server, port, address));
+	const base = config.base ?? "/";
+	return new URL(base, normalizedOrigin).href;
+}
+//#endregion
+//#region src/node/utils.ts
+const compress = promisify(gzip);
+function toArray(array) {
+	array ??= [];
+	return Array.isArray(array) ? array : [array];
+}
+async function getCompressedSize(code) {
+	return ` / gzip: ${((await compress(typeof code === "string" ? code : Buffer.from(code))).length / 1024).toFixed(2)} KiB`;
+}
+async function printFileInfo({ root, outDir, filePath, content, type, maxLength }) {
+	const prettyOutDir = `${normalize(relative(root, resolve(root, outDir)))}/`;
+	const kibs = content.length / 1024;
+	const compressedSize = await getCompressedSize(content);
+	const writeColor = type === "chunk" ? colors.cyan : colors.magenta;
+	consola.log(colors.white(colors.dim(prettyOutDir)) + writeColor(filePath.padEnd(maxLength + 2)) + colors.dim(`${kibs.toFixed(2)} kB${compressedSize}`));
+}
+//#endregion
+//#region src/node/index.ts
+let resolvedKirbyupConfig;
+let resolvedPostCssConfig;
+const logLevel = "warn";
+const logger = createLogger(logLevel);
+const loggerWarn = logger.warn;
+logger.warn = (msg, options) => {
+	if (msg.includes("(!) build.outDir")) return;
+	loggerWarn(msg, options);
+};
+function getViteConfig(command, options) {
+	const aliasDir = resolve(options.cwd, dirname(options.entry));
+	const { alias = {}, vite, extendViteConfig } = resolvedKirbyupConfig;
+	const userConfig = vite ?? extendViteConfig ?? {};
+	const sharedConfig = {
+		resolve: { alias: {
+			"~/": `${aliasDir}/`,
+			"@/": `${aliasDir}/`,
+			...alias
+		} },
+		plugins: [
+			vuePlugin({ compiler: vueCompilerSfc }),
+			vueJsxPlugin(),
+			kirbyupGlobImportPlugin(),
+			{
+				...externalGlobals({ vue: "Vue" }),
+				enforce: "post"
+			}
+		],
+		build: { copyPublicDir: false },
+		...resolvedPostCssConfig && { css: { postcss: resolvedPostCssConfig } },
+		envDir: options.cwd,
+		envPrefix: ["VITE_", "KIRBYUP_"],
+		customLogger: logger,
+		logLevel
+	};
+	if (command === "serve") {
+		const { port, watch } = options;
+		const userServerConfig = userConfig.server || {};
+		const resolvedPort = userServerConfig.port ?? port;
+		const inferredOrigin = userServerConfig.origin ?? resolveOriginFromServerOptions(userServerConfig, resolvedPort, "localhost");
+		const serveConfig = mergeConfig(sharedConfig, {
+			plugins: [kirbyupHmrPlugin(options), watch && fullReloadPlugin(watch)].filter(Boolean),
+			build: { rollupOptions: { input: resolve(options.cwd, options.entry) } },
+			server: {
+				port: resolvedPort,
+				strictPort: true,
+				origin: inferredOrigin
+			}
+		});
+		return mergeConfig(serveConfig, userConfig);
+	}
+	const mode = options.watch ? "development" : "production";
+	const buildConfig = mergeConfig(sharedConfig, {
+		mode,
+		plugins: [kirbyupBuildCleanupPlugin(options)],
+		build: {
+			lib: {
+				entry: resolve(options.cwd, options.entry),
+				formats: ["iife"],
+				name: "kirbyupExport",
+				fileName: () => "index.js"
+			},
+			minify: mode === "production",
+			outDir: options.outDir,
+			emptyOutDir: false,
+			rollupOptions: { output: { assetFileNames: "index.[ext]" } }
+		}
+	});
+	return mergeConfig(buildConfig, userConfig);
+}
+async function generate(options) {
+	const config = getViteConfig("build", options);
+	let result;
+	try {
+		result = await build(config);
+	} catch (error) {
+		consola.error(error);
+		if (config.mode === "production") throw error;
+	}
+	if (result && !options.watch) {
+		const { output } = toArray(result)[0];
+		let maxLength = 0;
+		for (const chunkFile in output) {
+			const fileNameLength = output[chunkFile].fileName.length;
+			if (fileNameLength > maxLength) maxLength = fileNameLength;
+		}
+		for (const { fileName, type, code } of output) {
+			const content = code || await fsp.readFile(resolve(options.outDir, fileName), "utf8");
+			await printFileInfo({
+				root: options.cwd,
+				outDir: options.outDir,
+				filePath: fileName,
+				content,
+				type,
+				maxLength
+			});
+		}
+	}
+	return result;
+}
+async function build$1(options) {
+	assertEntryExists(options);
+	const { cwd } = options;
+	const { config, configFile } = await loadConfig$1(cwd);
+	resolvedKirbyupConfig = config ?? {};
+	resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
+	consola.log(colors.green(`${name} v${version}`));
+	consola.start(`Building ${colors.cyan(options.entry)}`);
+	const debouncedBuild = debounce(async () => {
+		generate(options).catch(handleError);
+	}, 100);
+	const startWatcher = async () => {
+		if (!options.watch) return;
+		const { watch } = await import("chokidar");
+		const ignored = ["**/{.git,node_modules}/**", "index.{css,js}"];
+		const watchPaths = typeof options.watch === "boolean" ? dirname(options.entry) : Array.isArray(options.watch) ? options.watch.filter((path) => typeof path === "string") : options.watch;
+		consola.info(`Watching for changes in ${toArray(watchPaths).map((i) => colors.cyan(i)).join(", ")}`);
+		const watcher = watch(watchPaths, {
+			ignoreInitial: true,
+			ignorePermissionErrors: true,
+			ignored,
+			cwd
+		});
+		if (configFile) watcher.add(configFile);
+		watcher.on("all", async (type, file) => {
+			const absolutePath = resolve(cwd, file);
+			if (configFile === absolutePath) {
+				resolvedKirbyupConfig = (await loadConfig$1(cwd)).config ?? {};
+				consola.info(`${colors.cyan(basename(file))} changed, setting new config`);
+			} else consola.log(`${colors.green(type)} ${colors.white(colors.dim(file))}`);
+			debouncedBuild();
+		});
+	};
+	await generate(options);
+	consola.success("Build successful");
+	startWatcher();
+}
+async function serve(options) {
+	assertEntryExists(options);
+	const { cwd } = options;
+	const { config } = await loadConfig$1(cwd);
+	resolvedKirbyupConfig = config ?? {};
+	resolvedPostCssConfig = await resolvePostCSSConfig(cwd);
+	consola.log(colors.green(`${name} v${version}`));
+	consola.info("Starting development server…");
+	const server = await createServer(getViteConfig("serve", options));
+	await server.listen();
+	consola.success(`Server is listening on :${server.config.server.port}`);
+	return server;
+}
+function assertEntryExists(options) {
+	if (!fs.existsSync(resolve(options.cwd, options.entry))) throw new PrettyError(`Cannot find "${options.entry}"`);
+}
+//#endregion
+export { version as a, name as i, serve as n, handleError as r, build$1 as t };

package/dist/types-C3c_wslr.d.mts

@@ -0,0 +1,43 @@
+import { AliasOptions, InlineConfig } from "vite";
+import "postcss";
+//#region src/node/types.d.ts
+interface BaseOptions {
+  cwd: string;
+  entry: string;
+}
+interface ServeOptions extends BaseOptions {
+  watch: false | string | string[];
+  port: number;
+  outDir?: string;
+}
+interface BuildOptions extends BaseOptions {
+  outDir: string;
+  watch: boolean | string | string[];
+}
+interface UserConfig {
+  /**
+   * Object or array of objects defining aliases that replace values in
+   * `import` statements. With either format, the order of the entries
+   * matters: the first defined rules are applied first.
+   */
+  alias?: AliasOptions;
+  /**
+   * Additional Vite configuration, merged into kirbyup's defaults – for
+   * example, to define global constant replacements.
+   *
+   * @example
+   * export default defineConfig({
+   *   vite: {
+   *    define: {
+   *     __TEST__: JSON.stringify(process.env.TEST === 'true'),
+   *   },
+   * })
+   */
+  vite?: InlineConfig;
+  /**
+   * @deprecated Use `vite` instead.
+   */
+  extendViteConfig?: InlineConfig;
+}
+//#endregion
+export { ServeOptions as n, UserConfig as r, BuildOptions as t };