@open-slide/core 0.0.2 → 0.0.4

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './dist/cli/bin.js';

package/dist/{build-DJGuOT6x.js → build-CuoESF2g.js}

@@ -1,4 +1,4 @@
-import { createViteConfig } from "./config-Opp2R1Jf.js";
+import { createViteConfig } from "./config-DF58h0l4.js";
 import { build as build$1 } from "vite";
 
 //#region src/cli/build.ts

package/dist/cli/bin.js

@@ -4,11 +4,11 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 //#region src/cli/run.ts
-const HELP = `open-slide — author decks, we handle the Vite/React stack
+const HELP = `open-slide — author slides, we handle the Vite/React stack
 
 Usage:
   open-slide dev              Start dev server
-  open-slide build            Build a static deck site
+  open-slide build            Build a static site
   open-slide preview          Preview the production build
   open-slide --help           Show this message
   open-slide --version        Print version
@@ -30,17 +30,17 @@ async function run(argv) {
 		return;
 	}
 	if (cmd === "dev") {
-		const { dev } = await import("../dev-0SG0ArzD.js");
+		const { dev } = await import("../dev-rlOZacWo.js");
 		await dev();
 		return;
 	}
 	if (cmd === "build") {
-		const { build } = await import("../build-DJGuOT6x.js");
+		const { build } = await import("../build-CuoESF2g.js");
 		await build();
 		return;
 	}
 	if (cmd === "preview") {
-		const { preview } = await import("../preview-61Aawrlg.js");
+		const { preview } = await import("../preview-DCrD9X36.js");
 		await preview();
 		return;
 	}

package/dist/config-DF58h0l4.js

@@ -0,0 +1,641 @@
+import fs, { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { randomUUID } from "node:crypto";
+import fg from "fast-glob";
+
+//#region src/vite/comments-plugin.ts
+const MARKER_RE = /\{\/\*\s*@slide-comment\s+id="(c-[a-f0-9]+)"\s+ts="([^"]+)"\s+text="([A-Za-z0-9_-]+={0,2})"\s*\*\/\}/g;
+const SLIDE_ID_RE$1 = /^[a-z0-9_-]+$/i;
+function b64urlEncode(s) {
+	return Buffer.from(s, "utf8").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function b64urlDecode(s) {
+	const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+	return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/") + pad, "base64").toString("utf8");
+}
+async function readBody$1(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => {
+			const raw = Buffer.concat(chunks).toString("utf8");
+			if (!raw) return resolve({});
+			try {
+				resolve(JSON.parse(raw));
+			} catch (e) {
+				reject(e);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function json$1(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	res.end(JSON.stringify(body));
+}
+function resolveSlidePath(userCwd, slidesDir, slideId) {
+	if (!SLIDE_ID_RE$1.test(slideId)) return null;
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const full = path.resolve(slidesRoot, slideId, "index.tsx");
+	if (!full.startsWith(slidesRoot + path.sep)) return null;
+	return full;
+}
+function parseMarkers(source) {
+	const comments = [];
+	const lines = source.split("\n");
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		MARKER_RE.lastIndex = 0;
+		const m = MARKER_RE.exec(line);
+		if (!m) continue;
+		const [, id, ts, textB64] = m;
+		try {
+			const payload = JSON.parse(b64urlDecode(textB64));
+			comments.push({
+				id,
+				line: i + 1,
+				ts,
+				note: payload.note,
+				hint: payload.hint
+			});
+		} catch {}
+	}
+	return comments;
+}
+function newId() {
+	return `c-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function isJsxOpeningLine(line) {
+	const t = line.trimStart();
+	if (!t.startsWith("<")) return false;
+	if (t.startsWith("</")) return false;
+	if (t.startsWith("<!")) return false;
+	return true;
+}
+/**
+* Find the line index to insert a JSX comment above.
+*
+* Babel's `_debugSource.lineNumber/columnNumber` points at the `<` of a JSX
+* opening tag, but the value can go stale (HMR races) or, per reports, point
+* at a line that's not actually a JSX boundary — e.g. inside an inline style
+* object. Verify with the source of truth before committing.
+*/
+function findSafeInsertLine(lines, line, column) {
+	const idx = line - 1;
+	if (idx < 0 || idx >= lines.length) return null;
+	if (column !== void 0 && lines[idx].charAt(column) === "<") return idx;
+	if (isJsxOpeningLine(lines[idx])) return idx;
+	const WINDOW = 30;
+	for (let i = idx - 1; i >= Math.max(0, idx - WINDOW); i--) if (isJsxOpeningLine(lines[i])) return i;
+	for (let i = idx + 1; i < Math.min(lines.length, idx + WINDOW); i++) if (isJsxOpeningLine(lines[i])) return i;
+	return null;
+}
+function commentsPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	return {
+		name: "open-slide:comments",
+		apply: "serve",
+		configureServer(server) {
+			server.middlewares.use("/__comments", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				try {
+					if (method === "GET" && url.pathname === "/") {
+						const slideId = url.searchParams.get("slideId") ?? "";
+						const file = resolveSlidePath(userCwd, slidesDir, slideId);
+						if (!file) return json$1(res, 400, { error: "invalid slideId" });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json$1(res, 404, { error: "slide not found" });
+						}
+						return json$1(res, 200, { comments: parseMarkers(source) });
+					}
+					if (method === "POST" && url.pathname === "/add") {
+						const body = await readBody$1(req);
+						const slideId = body.slideId ?? "";
+						const file = resolveSlidePath(userCwd, slidesDir, slideId);
+						if (!file) return json$1(res, 400, { error: "invalid slideId" });
+						if (!body.line || body.line < 1) return json$1(res, 400, { error: "invalid line" });
+						if (!body.text || typeof body.text !== "string") return json$1(res, 400, { error: "missing text" });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json$1(res, 404, { error: "slide not found" });
+						}
+						const lines = source.split("\n");
+						const idx = findSafeInsertLine(lines, body.line, body.column);
+						if (idx === null) return json$1(res, 422, { error: `could not find a safe JSX boundary near line ${body.line}. Try clicking a different element.` });
+						const indent = lines[idx].match(/^\s*/)?.[0] ?? "";
+						const id = newId();
+						const ts = new Date().toISOString();
+						const payload = b64urlEncode(JSON.stringify({
+							note: body.text,
+							hint: body.hint
+						}));
+						const marker = `${indent}{/* @slide-comment id="${id}" ts="${ts}" text="${payload}" */}`;
+						lines.splice(idx, 0, marker);
+						await fs.writeFile(file, lines.join("\n"), "utf8");
+						return json$1(res, 200, {
+							id,
+							line: idx + 1
+						});
+					}
+					if (method === "DELETE" && url.pathname.startsWith("/")) {
+						const id = url.pathname.slice(1);
+						if (!/^c-[a-f0-9]+$/.test(id)) return json$1(res, 400, { error: "invalid id" });
+						const slideId = url.searchParams.get("slideId") ?? "";
+						const file = resolveSlidePath(userCwd, slidesDir, slideId);
+						if (!file) return json$1(res, 400, { error: "invalid slideId" });
+						let source;
+						try {
+							source = await fs.readFile(file, "utf8");
+						} catch {
+							return json$1(res, 404, { error: "slide not found" });
+						}
+						const lines = source.split("\n");
+						const idRe = new RegExp(`\\{\\/\\*\\s*@slide-comment\\s+id="${id}"\\s+ts="[^"]+"\\s+text="[A-Za-z0-9_\\-]+={0,2}"\\s*\\*\\/\\}`);
+						const hit = lines.findIndex((l) => idRe.test(l));
+						if (hit === -1) return json$1(res, 404, { error: "marker not found" });
+						lines.splice(hit, 1);
+						await fs.writeFile(file, lines.join("\n"), "utf8");
+						return json$1(res, 200, { ok: true });
+					}
+					next();
+				} catch (err) {
+					json$1(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/files-plugin.ts
+const FOLDER_ID_RE = /^f-[a-f0-9]{8}$/;
+const SLIDE_ID_RE = /^[a-z0-9_-]+$/i;
+const COLOR_RE = /^#[0-9a-fA-F]{6}$/;
+async function readBody(req) {
+	return await new Promise((resolve, reject) => {
+		const chunks = [];
+		req.on("data", (c) => chunks.push(c));
+		req.on("end", () => {
+			const raw = Buffer.concat(chunks).toString("utf8");
+			if (!raw) return resolve({});
+			try {
+				resolve(JSON.parse(raw));
+			} catch (e) {
+				reject(e);
+			}
+		});
+		req.on("error", reject);
+	});
+}
+function json(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("content-type", "application/json");
+	res.end(JSON.stringify(body));
+}
+function emptyManifest() {
+	return {
+		folders: [],
+		assignments: {}
+	};
+}
+async function readManifest(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 emptyManifest();
+		throw err;
+	}
+}
+async function writeManifest(file, manifest) {
+	await fs.mkdir(path.dirname(file), { recursive: true });
+	await fs.writeFile(file, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+}
+function newFolderId() {
+	return `f-${randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+function validateName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 40) return null;
+	return trimmed;
+}
+function validateSlideName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 80) return null;
+	return trimmed;
+}
+async function rmSlideDir(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return false;
+	const dir = path.resolve(slidesRoot, slideId);
+	if (!dir.startsWith(slidesRoot + path.sep)) return false;
+	try {
+		await fs.rm(dir, {
+			recursive: true,
+			force: true
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveSlideEntry(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return null;
+	const dir = path.resolve(slidesRoot, slideId);
+	if (!dir.startsWith(slidesRoot + 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 slide 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: SlideMeta = { title: ${newLiteral} };\n\n`;
+	return source.slice(0, exportDefaultIdx) + insertion + source.slice(exportDefaultIdx);
+}
+function validateIcon(v) {
+	if (!v || typeof v !== "object") return null;
+	const icon = v;
+	if (icon.type === "emoji") {
+		if (typeof icon.value !== "string") return null;
+		if (icon.value.length < 1 || icon.value.length > 8) return null;
+		return {
+			type: "emoji",
+			value: icon.value
+		};
+	}
+	if (icon.type === "color") {
+		if (typeof icon.value !== "string" || !COLOR_RE.test(icon.value)) return null;
+		return {
+			type: "color",
+			value: icon.value
+		};
+	}
+	return null;
+}
+function filesPlugin(opts) {
+	const userCwd = opts.userCwd;
+	const slidesDir = opts.slidesDir ?? "slides";
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	const manifestPath = path.join(slidesRoot, ".folders.json");
+	return {
+		name: "open-slide:files",
+		apply: "serve",
+		configureServer(server) {
+			server.watcher.add(manifestPath);
+			server.watcher.on("change", (p) => {
+				if (p === manifestPath) server.ws.send({
+					type: "custom",
+					event: "open-slide:files-changed"
+				});
+			});
+			server.middlewares.use("/__slides", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				try {
+					const idMatch = url.pathname.match(/^\/([^/]+)$/);
+					if (!idMatch) return next();
+					const slideId = idMatch[1];
+					if (!SLIDE_ID_RE.test(slideId)) return json(res, 400, { error: "invalid slideId" });
+					if (method === "PATCH") {
+						const body = await readBody(req);
+						const name = validateSlideName(body.name);
+						if (!name) return json(res, 400, { error: "invalid name" });
+						const entry = resolveSlideEntry(slidesRoot, slideId);
+						if (!entry) return json(res, 400, { error: "invalid slideId" });
+						let source;
+						try {
+							source = await fs.readFile(entry, "utf8");
+						} catch {
+							return json(res, 404, { error: "slide not found" });
+						}
+						const updated = updateMetaTitleInSource(source, name);
+						if (updated === null) return json(res, 422, { error: "could not locate a safe place to write meta.title in index.tsx" });
+						if (updated !== source) await fs.writeFile(entry, updated, "utf8");
+						server.ws.send({ type: "full-reload" });
+						return json(res, 200, {
+							ok: true,
+							slideId,
+							name
+						});
+					}
+					if (method === "DELETE") {
+						const removed = await rmSlideDir(slidesRoot, slideId);
+						if (!removed) return json(res, 404, { error: "slide not found" });
+						const manifest = await readManifest(manifestPath);
+						delete manifest.assignments[slideId];
+						await writeManifest(manifestPath, manifest);
+						return json(res, 200, { ok: true });
+					}
+					return next();
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+			server.middlewares.use("/__folders", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				try {
+					if (method === "GET" && url.pathname === "/") {
+						const manifest = await readManifest(manifestPath);
+						return json(res, 200, manifest);
+					}
+					if (method === "POST" && url.pathname === "/") {
+						const body = await readBody(req);
+						const name = validateName(body.name);
+						if (!name) return json(res, 400, { error: "invalid name" });
+						const icon = validateIcon(body.icon);
+						if (!icon) return json(res, 400, { error: "invalid icon" });
+						const manifest = await readManifest(manifestPath);
+						const folder = {
+							id: newFolderId(),
+							name,
+							icon
+						};
+						manifest.folders.push(folder);
+						await writeManifest(manifestPath, manifest);
+						return json(res, 200, folder);
+					}
+					if (method === "PUT" && url.pathname === "/assign") {
+						const body = await readBody(req);
+						if (typeof body.slideId !== "string" || !SLIDE_ID_RE.test(body.slideId)) return json(res, 400, { error: "invalid slideId" });
+						const slideId = body.slideId;
+						let folderId;
+						if (body.folderId === null) folderId = null;
+						else if (typeof body.folderId === "string" && FOLDER_ID_RE.test(body.folderId)) folderId = body.folderId;
+						else return json(res, 400, { error: "invalid folderId" });
+						const manifest = await readManifest(manifestPath);
+						if (folderId && !manifest.folders.some((f) => f.id === folderId)) return json(res, 404, { error: "folder not found" });
+						if (folderId === null) delete manifest.assignments[slideId];
+						else manifest.assignments[slideId] = folderId;
+						await writeManifest(manifestPath, manifest);
+						return json(res, 200, { ok: true });
+					}
+					const idMatch = url.pathname.match(/^\/([^/]+)$/);
+					if (idMatch) {
+						const id = idMatch[1];
+						if (!FOLDER_ID_RE.test(id)) return json(res, 400, { error: "invalid id" });
+						if (method === "PATCH") {
+							const body = await readBody(req);
+							const manifest = await readManifest(manifestPath);
+							const folder = manifest.folders.find((f) => f.id === id);
+							if (!folder) return json(res, 404, { error: "folder not found" });
+							if (body.name !== void 0) {
+								const name = validateName(body.name);
+								if (!name) return json(res, 400, { error: "invalid name" });
+								folder.name = name;
+							}
+							if (body.icon !== void 0) {
+								const icon = validateIcon(body.icon);
+								if (!icon) return json(res, 400, { error: "invalid icon" });
+								folder.icon = icon;
+							}
+							await writeManifest(manifestPath, manifest);
+							return json(res, 200, folder);
+						}
+						if (method === "DELETE") {
+							const manifest = await readManifest(manifestPath);
+							const before = manifest.folders.length;
+							manifest.folders = manifest.folders.filter((f) => f.id !== id);
+							if (manifest.folders.length === before) return json(res, 404, { error: "folder not found" });
+							for (const [slideId, folderId] of Object.entries(manifest.assignments)) if (folderId === id) delete manifest.assignments[slideId];
+							await writeManifest(manifestPath, manifest);
+							return json(res, 200, { ok: true });
+						}
+					}
+					next();
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+		}
+	};
+}
+
+//#endregion
+//#region src/vite/open-slide-plugin.ts
+const SLIDES_VMOD = "virtual:open-slide/slides";
+const CONFIG_VMOD = "virtual:open-slide/config";
+function resolved(id) {
+	return `\0${id}`;
+}
+async function findSlides(userCwd, slidesDir) {
+	const abs = path.resolve(userCwd, slidesDir);
+	if (!existsSync(abs)) return [];
+	const hits = await fg("*/index.{tsx,jsx,ts,js}", {
+		cwd: abs,
+		absolute: true,
+		onlyFiles: true
+	});
+	return hits.sort();
+}
+function toId(absFile, slidesRoot) {
+	const rel = path.relative(slidesRoot, absFile);
+	return rel.split(path.sep)[0];
+}
+function generateSlidesModule(files, slidesRoot, isDev) {
+	const entries = files.map((abs) => {
+		const id = toId(abs, slidesRoot);
+		const importPath = isDev ? `/@fs${abs}` : abs;
+		return {
+			id,
+			importPath
+		};
+	});
+	const ids = JSON.stringify(entries.map((e) => e.id).sort());
+	const cases = entries.map((e) => `    case ${JSON.stringify(e.id)}: return import(${JSON.stringify(e.importPath)});`).join("\n");
+	return `// virtual:open-slide/slides — generated
+export const slideIds = ${ids};
+
+export async function loadSlide(id) {
+  switch (id) {
+${cases}
+    default: throw new Error('Slide not found: ' + id);
+  }
+}
+`;
+}
+function openSlidePlugin(opts) {
+	const { userCwd, config } = opts;
+	const slidesDir = config.slidesDir ?? "slides";
+	const slidesRoot = path.resolve(userCwd, slidesDir);
+	let isDev = false;
+	return {
+		name: "open-slide",
+		config(_c, env) {
+			isDev = env.command === "serve";
+			return { server: { fs: { allow: [userCwd] } } };
+		},
+		resolveId(id) {
+			if (id === SLIDES_VMOD) return resolved(SLIDES_VMOD);
+			if (id === CONFIG_VMOD) return resolved(CONFIG_VMOD);
+			return null;
+		},
+		async load(id) {
+			if (id === resolved(SLIDES_VMOD)) {
+				const files = await findSlides(userCwd, slidesDir);
+				return generateSlidesModule(files, slidesRoot, isDev);
+			}
+			if (id === resolved(CONFIG_VMOD)) return `export default ${JSON.stringify(config)};\n`;
+			return null;
+		},
+		configureServer(server) {
+			const reload = () => {
+				const mod = server.moduleGraph.getModuleById(resolved(SLIDES_VMOD));
+				if (mod) server.moduleGraph.invalidateModule(mod);
+				server.ws.send({ type: "full-reload" });
+			};
+			server.watcher.add(path.join(slidesRoot, "*"));
+			server.watcher.on("add", (p) => {
+				if (p.startsWith(slidesRoot)) reload();
+			});
+			server.watcher.on("unlink", (p) => {
+				if (p.startsWith(slidesRoot)) reload();
+			});
+			server.middlewares.use("/__open-slide/title", (_req, res) => {
+				res.setHeader("content-type", "application/json");
+				res.end(JSON.stringify({ title: config.title ?? null }));
+			});
+		}
+	};
+}
+async function loadUserConfig(userCwd) {
+	const file = path.join(userCwd, "open-slide.json");
+	if (!existsSync(file)) return {};
+	const raw = await readFile(file, "utf8");
+	return JSON.parse(raw);
+}
+
+//#endregion
+//#region src/vite/config.ts
+function findPackageRoot(fromFile) {
+	let dir = path.dirname(fromFile);
+	while (dir !== path.dirname(dir)) {
+		if (existsSync(path.join(dir, "package.json"))) return dir;
+		dir = path.dirname(dir);
+	}
+	throw new Error(`Could not find package.json walking up from ${fromFile}`);
+}
+const PKG_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
+const APP_ROOT = path.join(PKG_ROOT, "src", "app");
+async function createViteConfig(opts) {
+	const userCwd = path.resolve(opts.userCwd);
+	const config = opts.config ?? await loadUserConfig(userCwd);
+	const slidesDir = config.slidesDir ?? "slides";
+	const slidesAbs = path.resolve(userCwd, slidesDir);
+	return {
+		root: APP_ROOT,
+		configFile: false,
+		plugins: [
+			react(),
+			tailwindcss(),
+			openSlidePlugin({
+				userCwd,
+				config
+			}),
+			commentsPlugin({
+				userCwd,
+				slidesDir
+			}),
+			filesPlugin({
+				userCwd,
+				slidesDir
+			})
+		],
+		resolve: { alias: { "@": APP_ROOT } },
+		optimizeDeps: {
+			entries: [path.join(APP_ROOT, "main.tsx")],
+			include: [
+				"react-router-dom",
+				"radix-ui",
+				"lucide-react",
+				"clsx",
+				"tailwind-merge",
+				"class-variance-authority",
+				"emoji-picker-react"
+			]
+		},
+		server: {
+			port: config.port ?? 5173,
+			fs: { allow: [
+				APP_ROOT,
+				userCwd,
+				slidesAbs
+			] }
+		},
+		build: {
+			outDir: path.resolve(userCwd, "dist"),
+			emptyOutDir: true
+		}
+	};
+}
+
+//#endregion
+export { createViteConfig };

package/dist/{dev-0SG0ArzD.js → dev-rlOZacWo.js}

@@ -1,4 +1,4 @@
-import { createViteConfig } from "./config-Opp2R1Jf.js";
+import { createViteConfig } from "./config-DF58h0l4.js";
 import { createServer } from "vite";
 
 //#region src/cli/dev.ts