@autono/open-pages 0.1.0

package/dist/open-pages-plugin-D_DN_zjh.js

@@ -0,0 +1,632 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { loadConfigFromFile, normalizePath } from "vite";
+import { parse } from "@babel/parser";
+import { createRequire } from "node:module";
+import fg from "fast-glob";
+
+//#region src/editing/page-ops.ts
+const PAGE_ID_RE = /^[a-z0-9_-]+$/i;
+function validatePageName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 80) return null;
+	return trimmed;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (current && (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression")) current = current.expression;
+	return current;
+}
+function readMetaTitleInSource(source) {
+	let ast;
+	try {
+		ast = parse(source, {
+			sourceType: "module",
+			plugins: ["typescript", "jsx"],
+			errorRecovery: true
+		});
+	} catch {
+		return { kind: "unsupported" };
+	}
+	const body = ast.program?.body ?? [];
+	for (const stmt of body) {
+		if (stmt.type !== "ExportNamedDeclaration") continue;
+		const decl = stmt.declaration;
+		if (!decl || decl.type !== "VariableDeclaration") continue;
+		const declarations = decl.declarations ?? [];
+		for (const d of declarations) {
+			const id = d.id;
+			if (!id || id.type !== "Identifier" || id.name !== "meta") continue;
+			const init = unwrapExpression(d.init);
+			if (!init || init.type !== "ObjectExpression") return { kind: "unsupported" };
+			const properties = init.properties ?? [];
+			for (const property of properties) {
+				if (property.type !== "ObjectProperty" || property.computed) continue;
+				const key = property.key;
+				const keyName = key?.type === "Identifier" ? key.name : key?.type === "StringLiteral" ? key.value : void 0;
+				if (keyName !== "title") continue;
+				const value = property.value;
+				if (value?.type === "StringLiteral" && typeof value.value === "string") return {
+					kind: "found",
+					title: value.value
+				};
+				if (value?.type === "TemplateLiteral") {
+					const expressions = value.expressions ?? [];
+					const quasis = value.quasis ?? [];
+					const firstValue = quasis[0]?.value;
+					const cooked = firstValue?.cooked;
+					const raw = firstValue?.raw;
+					if (expressions.length === 0 && typeof (cooked ?? raw) === "string") return {
+						kind: "found",
+						title: cooked ?? raw
+					};
+				}
+				return { kind: "unsupported" };
+			}
+			return { kind: "missing" };
+		}
+	}
+	return { kind: "missing" };
+}
+async function rmPageDir(pagesRoot, pageId) {
+	if (!PAGE_ID_RE.test(pageId)) return false;
+	const dir = path.resolve(pagesRoot, pageId);
+	if (!dir.startsWith(pagesRoot + path.sep)) return false;
+	try {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function duplicatePageDir(pagesRoot, pageId, desiredId) {
+	if (!PAGE_ID_RE.test(pageId)) return {
+		ok: false,
+		status: 400,
+		error: "invalid pageId"
+	};
+	const root = path.resolve(pagesRoot);
+	const srcDir = path.resolve(root, pageId);
+	if (!srcDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid pageId"
+	};
+	try {
+		await fs.access(path.join(srcDir, "index.tsx"));
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "page not found"
+		};
+	}
+	let newId;
+	if (desiredId !== void 0) {
+		if (!PAGE_ID_RE.test(desiredId)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		newId = desiredId;
+		const dstDir$1 = path.resolve(root, newId);
+		if (!dstDir$1.startsWith(root + path.sep)) return {
+			ok: false,
+			status: 400,
+			error: "invalid newId"
+		};
+		try {
+			await fs.access(dstDir$1);
+			return {
+				ok: false,
+				status: 409,
+				error: "page already exists"
+			};
+		} catch {}
+	} else {
+		let suffix = 1;
+		while (true) {
+			newId = suffix === 1 ? `${pageId}-copy` : `${pageId}-copy-${suffix}`;
+			try {
+				await fs.access(path.resolve(root, newId));
+				suffix++;
+			} catch {
+				break;
+			}
+		}
+	}
+	const dstDir = path.resolve(root, newId);
+	if (!dstDir.startsWith(root + path.sep)) return {
+		ok: false,
+		status: 400,
+		error: "invalid newId"
+	};
+	const srcEntry = path.join(srcDir, "index.tsx");
+	let copiedEntrySource;
+	try {
+		const source = await fs.readFile(srcEntry, "utf8");
+		const metaTitle = readMetaTitleInSource(source);
+		if (metaTitle.kind === "unsupported") return {
+			ok: false,
+			status: 422,
+			error: "could not update copied page title"
+		};
+		const title = metaTitle.kind === "found" ? metaTitle.title : pageId;
+		const updated = updateMetaTitleInSource(source, `${title} (copy)`);
+		if (updated === null) return {
+			ok: false,
+			status: 422,
+			error: "could not update copied page title"
+		};
+		copiedEntrySource = updated;
+	} catch {
+		return {
+			ok: false,
+			status: 404,
+			error: "page not found"
+		};
+	}
+	try {
+		await fs.cp(srcDir, dstDir, {
+			recursive: true,
+			errorOnExist: true,
+			force: false
+		});
+		await fs.writeFile(path.join(dstDir, "index.tsx"), copiedEntrySource, "utf8");
+		return {
+			ok: true,
+			pageId: newId
+		};
+	} catch (err) {
+		if (err.code === "EEXIST") return {
+			ok: false,
+			status: 409,
+			error: "page already exists"
+		};
+		return {
+			ok: false,
+			status: 500,
+			error: String(err.message ?? err)
+		};
+	}
+}
+function resolvePageEntry(pagesRoot, pageId) {
+	if (!PAGE_ID_RE.test(pageId)) return null;
+	const dir = path.resolve(pagesRoot, pageId);
+	if (!dir.startsWith(pagesRoot + path.sep)) return null;
+	return path.join(dir, "index.tsx");
+}
+function escapeSingleQuoted(s) {
+	return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+/**
+* Rewrite (or insert) the `title` field in the page module's `export const meta`.
+*
+* Strategy:
+*   1. Find `export const meta` and brace-match its object literal.
+*   2. If the object already has a `title: '...'` entry, replace the literal.
+*   3. If the object exists but has no title, inject a new `title: '...'` line
+*      as the first property (preserving the author's surrounding indentation).
+*   4. If there is no `meta` export at all, insert a fresh one right before
+*      `export default`.
+*
+* Returns the rewritten source, or `null` if the file shape was too surprising
+* to touch safely (e.g. `export default` missing when we'd need to inject meta).
+*/
+function updateMetaTitleInSource(source, title) {
+	const newLiteral = `'${escapeSingleQuoted(title)}'`;
+	const metaStart = source.search(/export\s+const\s+meta\b/);
+	if (metaStart !== -1) {
+		const eqIdx = source.indexOf("=", metaStart);
+		if (eqIdx === -1) return null;
+		const openBrace = source.indexOf("{", eqIdx);
+		if (openBrace === -1) return null;
+		let depth = 0;
+		let closeBrace = -1;
+		for (let i = openBrace; i < source.length; i++) {
+			const ch = source[i];
+			if (ch === "{") depth++;
+			else if (ch === "}") {
+				depth--;
+				if (depth === 0) {
+					closeBrace = i;
+					break;
+				}
+			}
+		}
+		if (closeBrace === -1) return null;
+		const body = source.slice(openBrace + 1, closeBrace);
+		const titleRe = /(^|[\s,{])(title\s*:\s*)(['"`])((?:\\.|(?!\3).)*)\3/;
+		const match = body.match(titleRe);
+		if (match) {
+			const newBody = body.replace(titleRe, `${match[1]}${match[2]}${newLiteral}`);
+			return source.slice(0, openBrace + 1) + newBody + source.slice(closeBrace);
+		}
+		const firstIndentMatch = body.match(/\n([ \t]+)\S/);
+		const indent = firstIndentMatch ? firstIndentMatch[1] : "  ";
+		const trimmedBody = body.replace(/^\s*\n?/, "");
+		const needsSeparator = trimmedBody.trim().length > 0;
+		const insertion$1 = `\n${indent}title: ${newLiteral}${needsSeparator ? "," : ""}`;
+		return source.slice(0, openBrace + 1) + insertion$1 + body + source.slice(closeBrace);
+	}
+	const exportDefaultIdx = source.search(/export\s+default\b/);
+	if (exportDefaultIdx === -1) return null;
+	const insertion = `export const meta: PageMeta = { title: ${newLiteral} };\n\n`;
+	return source.slice(0, exportDefaultIdx) + insertion + source.slice(exportDefaultIdx);
+}
+
+//#endregion
+//#region src/vite/open-pages-plugin.ts
+const CONFIG_FILE = "open-pages.config.ts";
+const PAGES_VMOD = "virtual:open-pages/pages";
+const CONFIG_VMOD = "virtual:open-pages/config";
+const FOLDERS_VMOD = "virtual:open-pages/folders";
+const PAGES_CSS_VMOD = "virtual:open-pages/pages.css";
+const ENTRY_GLOB = "*/index.{tsx,jsx,ts,js,html}";
+const REACT_ENTRY_RE = /^index\.(tsx|jsx|ts|js)$/;
+async function readFoldersManifest(file) {
+	try {
+		const raw = await fs.readFile(file, "utf8");
+		const parsed = JSON.parse(raw);
+		return {
+			folders: Array.isArray(parsed.folders) ? parsed.folders : [],
+			assignments: parsed.assignments && typeof parsed.assignments === "object" ? parsed.assignments : {}
+		};
+	} catch (err) {
+		if (err.code === "ENOENT") return {
+			folders: [],
+			assignments: {}
+		};
+		throw err;
+	}
+}
+function resolved(id) {
+	return `\0${id}`;
+}
+/**
+* Every `pages/<id>/index.*` entry. A folder with both a React entry and an
+* `index.html` is a React page — the HTML is then a plain asset of the page.
+*/
+async function findPages(userCwd, pagesDir) {
+	const abs = path.resolve(userCwd, pagesDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg(ENTRY_GLOB, {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	const byId = new Map();
+	for (const file of hits.sort()) {
+		const rel = path.relative(abs, file);
+		const [id, name] = rel.split(path.sep);
+		const kind = REACT_ENTRY_RE.test(name) ? "react" : "html";
+		const existing = byId.get(id);
+		if (!existing || existing.kind === "html" && kind === "react") byId.set(id, {
+			id,
+			kind,
+			file
+		});
+	}
+	return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+const META_THEME_RE = /(?:^|[\s,{])theme\s*:\s*['"]([^'"]+)['"]/;
+const META_CREATED_AT_RE = /(?:^|[\s,{])createdAt\s*:\s*['"]([^'"]+)['"]/;
+const META_TITLE_RE = /(?:^|[\s,{])title\s*:\s*['"]([^'"]+)['"]/;
+const HTML_TITLE_RE = /<title[^>]*>([^<]*)<\/title>/i;
+const EMPTY_META = {
+	title: null,
+	theme: null,
+	createdAt: null
+};
+function extractMeta(src) {
+	const metaStart = src.search(/export\s+const\s+meta\b/);
+	if (metaStart === -1) return EMPTY_META;
+	const eqIdx = src.indexOf("=", metaStart);
+	if (eqIdx === -1) return EMPTY_META;
+	const openBrace = src.indexOf("{", eqIdx);
+	if (openBrace === -1) return EMPTY_META;
+	let depth = 0;
+	let closeBrace = -1;
+	for (let i = openBrace; i < src.length; i++) {
+		const ch = src[i];
+		if (ch === "{") depth++;
+		else if (ch === "}") {
+			depth--;
+			if (depth === 0) {
+				closeBrace = i;
+				break;
+			}
+		}
+	}
+	if (closeBrace === -1) return EMPTY_META;
+	const body = src.slice(openBrace + 1, closeBrace);
+	return {
+		title: body.match(META_TITLE_RE)?.[1] ?? null,
+		theme: body.match(META_THEME_RE)?.[1] ?? null,
+		createdAt: body.match(META_CREATED_AT_RE)?.[1] ?? null
+	};
+}
+function extractHtmlMeta(src) {
+	const title = src.match(HTML_TITLE_RE)?.[1]?.trim() ?? null;
+	return {
+		title: title || null,
+		theme: null,
+		createdAt: null
+	};
+}
+async function readPageMeta(entry) {
+	try {
+		const src = await fs.readFile(entry.file, "utf8");
+		return entry.kind === "html" ? extractHtmlMeta(src) : extractMeta(src);
+	} catch {
+		return EMPTY_META;
+	}
+}
+function parseCreatedAtMs(iso) {
+	if (!iso) return null;
+	const ms = Date.parse(iso);
+	return Number.isFinite(ms) ? ms : null;
+}
+const warnedInvalidPageIds = new Set();
+async function generatePagesModule(entries, isDev) {
+	const scanned = await Promise.all(entries.map(async (entry) => {
+		const importPath = isDev ? `@fs/${normalizePath(entry.file).replace(/^\/+/, "")}` : entry.file;
+		const meta = await readPageMeta(entry);
+		return {
+			...entry,
+			importPath,
+			meta,
+			createdAt: parseCreatedAtMs(meta.createdAt)
+		};
+	}));
+	const valid = scanned.filter((e) => PAGE_ID_RE.test(e.id));
+	const ignored = scanned.filter((e) => !PAGE_ID_RE.test(e.id)).map((e) => e.id);
+	const kinds = {};
+	const themesMap = {};
+	const createdAtMap = {};
+	for (const e of valid) {
+		kinds[e.id] = e.kind;
+		if (e.meta.theme) themesMap[e.id] = e.meta.theme;
+		if (e.createdAt !== null) createdAtMap[e.id] = e.createdAt;
+	}
+	const importTokens = JSON.stringify(Object.fromEntries(valid.filter((e) => e.kind === "react").map((e) => [e.id, 0])));
+	const devRuntime = isDev ? `
+const pageImportTokens = ${importTokens};
+if (import.meta.hot) {
+  import.meta.hot.on('open-pages:page-changed', (data) => {
+    const ids = Array.isArray(data?.pageIds) ? data.pageIds : data?.pageId ? [data.pageId] : [];
+    const token = Date.now();
+    for (const id of ids) {
+      if (Object.prototype.hasOwnProperty.call(pageImportTokens, id)) pageImportTokens[id] = token;
+    }
+  });
+}
+` : "";
+	const cases = valid.map((e) => {
+		if (e.kind === "html") {
+			const mod = { meta: { title: e.meta.title ?? e.id } };
+			return `    case ${JSON.stringify(e.id)}: return Promise.resolve(${JSON.stringify(mod)});`;
+		}
+		const importExpr = isDev ? `import(/* @vite-ignore */ import.meta.env.BASE_URL + ${JSON.stringify(`${e.importPath}?t=`)} + pageImportTokens[${JSON.stringify(e.id)}])` : `import(${JSON.stringify(e.importPath)})`;
+		return `    case ${JSON.stringify(e.id)}: return ${importExpr};`;
+	}).join("\n");
+	const code = `// virtual:open-pages/pages — generated
+export const pageIds = ${JSON.stringify(valid.map((e) => e.id))};
+export const pageKinds = ${JSON.stringify(kinds)};
+export const pageThemes = ${JSON.stringify(themesMap)};
+export const pageCreatedAt = ${JSON.stringify(createdAtMap)};
+${devRuntime}
+
+export async function loadPage(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Page not found: ' + id);
+  }
+}
+`;
+	return {
+		code,
+		ignored
+	};
+}
+/**
+* Tailwind for page source. The workspace UI has its own stylesheet rooted
+* at the core app; pages live in the user's project, so they get a generated
+* stylesheet whose `@source` points at their directories. Written under
+* node_modules so Tailwind resolves `tailwindcss` from the workspace.
+*/
+function pagesCssFile(userCwd) {
+	return path.join(userCwd, "node_modules", ".open-pages", "pages.css");
+}
+const TAILWIND_CSS = normalizePath(createRequire(import.meta.url).resolve("tailwindcss/index.css"));
+function writePagesCss(userCwd, sources) {
+	const file = pagesCssFile(userCwd);
+	const lines = [`@import ${JSON.stringify(TAILWIND_CSS)} source(none);`];
+	for (const dir of sources) lines.push(`@source ${JSON.stringify(normalizePath(dir))};`);
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, `${lines.join("\n")}\n`, "utf8");
+	return file;
+}
+function rewriteHtmlUrls(html, pageDir) {
+	const prefix = `/@fs/${normalizePath(pageDir).replace(/^\/+/, "")}/`;
+	return html.replace(/(\s(?:src|href)=)(["'])(?!\/|[a-z][a-z0-9+.-]*:|#|\2)(?:\.\/)?([^"']+)\2/gi, (_m, attr, quote, rel) => `${attr}${quote}${prefix}${rel}${quote}`);
+}
+function openPagesPlugin(opts) {
+	const { userCwd, config, coreVersion } = opts;
+	const pagesDir = config.pagesDir ?? "pages";
+	const themesDir = config.themesDir ?? "themes";
+	const pagesRoot = path.resolve(userCwd, pagesDir);
+	const themesRoot = path.resolve(userCwd, themesDir);
+	const foldersManifestPath = path.join(pagesRoot, ".folders.json");
+	let isDev = false;
+	let cssFile = "";
+	const pageIdForEntry = (p) => {
+		const rel = path.relative(pagesRoot, p);
+		if (rel.startsWith("..") || path.isAbsolute(rel)) return null;
+		const parts = rel.split(path.sep);
+		if (parts.length !== 2) return null;
+		if (REACT_ENTRY_RE.test(parts[1])) return {
+			id: parts[0],
+			kind: "react"
+		};
+		if (parts[1] === "index.html") return {
+			id: parts[0],
+			kind: "html"
+		};
+		return null;
+	};
+	let pageChangeTimer = null;
+	const pendingPageChanges = new Set();
+	const queuePageChanged = (server, id) => {
+		pendingPageChanges.add(id);
+		if (pageChangeTimer) clearTimeout(pageChangeTimer);
+		pageChangeTimer = setTimeout(() => {
+			pageChangeTimer = null;
+			const mod = server.moduleGraph.getModuleById(resolved(PAGES_VMOD));
+			if (mod) server.moduleGraph.invalidateModule(mod);
+			const pageIds = Array.from(pendingPageChanges);
+			pendingPageChanges.clear();
+			server.ws.send({
+				type: "custom",
+				event: "open-pages:page-changed",
+				data: { pageIds }
+			});
+		}, 100);
+	};
+	return {
+		name: "open-pages",
+		config(_c, env) {
+			isDev = env.command === "serve";
+			cssFile = writePagesCss(userCwd, [pagesRoot, themesRoot]);
+			return { server: { fs: { allow: [userCwd] } } };
+		},
+		resolveId(id) {
+			if (id === PAGES_VMOD) return resolved(PAGES_VMOD);
+			if (id === CONFIG_VMOD) return resolved(CONFIG_VMOD);
+			if (id === FOLDERS_VMOD) return resolved(FOLDERS_VMOD);
+			if (id === PAGES_CSS_VMOD) return cssFile;
+			return null;
+		},
+		async load(id) {
+			if (id === resolved(PAGES_VMOD)) {
+				const entries = await findPages(userCwd, pagesDir);
+				const { code, ignored } = await generatePagesModule(entries, isDev);
+				for (const pageId of ignored) {
+					if (warnedInvalidPageIds.has(pageId)) continue;
+					warnedInvalidPageIds.add(pageId);
+					this.warn(`Ignoring page folder "${pageId}": page ids must match ${PAGE_ID_RE} (lowercase/uppercase letters, digits, "-", "_"). Rename the folder under "${pagesDir}/" to a kebab-case id so it appears in the browser and can be moved into folders.`);
+				}
+				return code;
+			}
+			if (id === resolved(CONFIG_VMOD)) {
+				const userBuild = config.build ?? {};
+				const buildResolved = isDev ? {
+					showPageBrowser: true,
+					showPageUi: true
+				} : {
+					showPageBrowser: userBuild.showPageBrowser ?? true,
+					showPageUi: userBuild.showPageUi ?? true
+				};
+				const resolvedConfig = {
+					...config,
+					build: buildResolved,
+					version: coreVersion
+				};
+				return `export default ${JSON.stringify(resolvedConfig)};\n`;
+			}
+			if (id === resolved(FOLDERS_VMOD)) {
+				const manifest = await readFoldersManifest(foldersManifestPath);
+				return `export default ${JSON.stringify(manifest)};\n`;
+			}
+			return null;
+		},
+		handleHotUpdate(ctx) {
+			const entry = pageIdForEntry(ctx.file);
+			if (!entry) return;
+			queuePageChanged(ctx.server, entry.id);
+			return [];
+		},
+		configureServer(server) {
+			let reloadTimer = null;
+			const reload = () => {
+				if (reloadTimer) clearTimeout(reloadTimer);
+				reloadTimer = setTimeout(() => {
+					reloadTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved(PAGES_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+					server.ws.send({ type: "full-reload" });
+				}, 150);
+			};
+			if (existsSync(pagesRoot)) server.watcher.add(pagesRoot);
+			server.watcher.on("add", (p) => {
+				if (pageIdForEntry(p)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (pageIdForEntry(p)) reload();
+			});
+			server.watcher.on("change", (p) => {
+				const entry = pageIdForEntry(p);
+				if (entry?.kind === "html") queuePageChanged(server, entry.id);
+			});
+			let foldersTimer = null;
+			const invalidateFolders = () => {
+				if (foldersTimer) clearTimeout(foldersTimer);
+				foldersTimer = setTimeout(() => {
+					foldersTimer = null;
+					const mod = server.moduleGraph.getModuleById(resolved(FOLDERS_VMOD));
+					if (mod) server.moduleGraph.invalidateModule(mod);
+				}, 100);
+			};
+			server.watcher.add(foldersManifestPath);
+			server.watcher.on("change", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("add", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (p === foldersManifestPath) invalidateFolders();
+			});
+			server.middlewares.use("/__page", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const m = url.pathname.match(/^\/([^/]+)\/(?:index\.html)?$/);
+				if (!m || (req.method ?? "GET") !== "GET") return next();
+				const pageId = decodeURIComponent(m[1]);
+				if (!PAGE_ID_RE.test(pageId)) return next();
+				const pageDir = path.join(pagesRoot, pageId);
+				const file = path.join(pageDir, "index.html");
+				let raw;
+				try {
+					raw = await fs.readFile(file, "utf8");
+				} catch {
+					return next();
+				}
+				try {
+					const html = await server.transformIndexHtml(`/__page/${pageId}/index.html`, rewriteHtmlUrls(raw, pageDir), req.originalUrl);
+					res.statusCode = 200;
+					res.setHeader("content-type", "text/html");
+					res.end(html);
+				} catch (err) {
+					next(err);
+				}
+			});
+		}
+	};
+}
+async function loadUserConfig(userCwd) {
+	const file = path.join(userCwd, CONFIG_FILE);
+	if (!existsSync(file)) return {};
+	const loaded = await loadConfigFromFile({
+		command: "serve",
+		mode: "development"
+	}, file, userCwd, "silent");
+	return loaded?.config ?? {};
+}
+
+//#endregion
+export { PAGE_ID_RE, duplicatePageDir, extractMeta, findPages, loadUserConfig, openPagesPlugin, resolvePageEntry, rmPageDir, updateMetaTitleInSource, validatePageName };

package/dist/preview-BrDuvgAN.js

@@ -0,0 +1,21 @@
+import "./design-C13iz9_4.js";
+import "./open-pages-plugin-D_DN_zjh.js";
+import { createViteConfig } from "./config-L0IbktJ0.js";
+import "./update-package-Cxt57pz7.js";
+import "./version-B6AiiGvT.js";
+import { mergeConfig, preview as preview$1 } from "vite";
+
+//#region src/cli/preview.ts
+async function preview(opts = {}) {
+	const base = await createViteConfig({ userCwd: process.cwd() });
+	const config = mergeConfig(base, { preview: {
+		...opts.port !== void 0 ? { port: opts.port } : {},
+		...opts.host !== void 0 ? { host: opts.host } : {},
+		...opts.open !== void 0 ? { open: opts.open } : {}
+	} });
+	const server = await preview$1(config);
+	server.printUrls();
+}
+
+//#endregion
+export { preview };