@stdout-design/cli 0.1.1 → 0.1.2

package/dist/dist-CZVUmY-d.mjs

@@ -1,590 +0,0 @@
-import { n as isZodObject, r as zodToJsonSchemaShape } from "./validation-CMTs74Vm-C3_d2dBv.mjs";
-import { c as logWarn, f as studioConfigSchema, i as compileTemplate, l as measureTemplate, n as ErrorCode, r as RenderCache, s as logError, u as renderToPixels } from "./dist-Dm76-R-V.mjs";
-import { z } from "zod";
-import path from "node:path";
-import { readFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { createElement } from "react";
-import { pathToFileURL } from "node:url";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { logger } from "hono/logger";
-import { streamSSE } from "hono/streaming";
-import { watch } from "chokidar";
-import react from "@vitejs/plugin-react";
-import { createServer } from "vite";
-import { ViteNodeRunner } from "vite-node/client";
-import { ViteNodeServer } from "vite-node/server";
-import { installSourcemapsSupport } from "vite-node/source-map";
-//#region ../dev-server/dist/index.mjs
-const errorHandler = (err, c) => {
-	logError(ErrorCode.INTERNAL_ERROR, "Unhandled server error", {
-		error: err.message,
-		method: c.req.method,
-		path: c.req.path,
-		stack: err.stack
-	});
-	return c.json({ error: "Internal server error" }, 500);
-};
-/**
-* Watches studio.config.ts and the templates/ directory, triggering
-* TemplateLoader reloads on change and notifying listeners (the dev-server
-* SSE endpoint) of what changed.
-*/
-var FileWatcher = class FileWatcher {
-	rootDir;
-	templateLoader;
-	listeners = /* @__PURE__ */ new Set();
-	debounceTimers = /* @__PURE__ */ new Map();
-	debounceMs;
-	watcher = null;
-	constructor(rootDir, templateLoader, options) {
-		this.rootDir = rootDir;
-		this.templateLoader = templateLoader;
-		this.debounceMs = options?.debounceMs ?? 200;
-	}
-	start() {
-		if (this.watcher) return;
-		const watchPaths = [`${this.rootDir}/templates`, `${this.rootDir}/studio.config.ts`];
-		this.watcher = watch(watchPaths, {
-			awaitWriteFinish: {
-				pollInterval: 50,
-				stabilityThreshold: 100
-			},
-			ignoreInitial: true
-		});
-		this.watcher.on("change", (filePath) => this.scheduleChange(filePath));
-		this.watcher.on("unlink", (filePath) => this.scheduleChange(filePath));
-		this.watcher.on("add", (filePath) => this.scheduleChange(filePath));
-		this.watcher.on("error", (error) => {
-			const normalizedError = error instanceof Error ? error : new Error(String(error));
-			this.emit({
-				error: normalizedError,
-				type: "template-error"
-			});
-		});
-	}
-	async stop() {
-		for (const timer of this.debounceTimers.values()) clearTimeout(timer);
-		this.debounceTimers.clear();
-		await this.watcher?.close();
-		this.watcher = null;
-	}
-	onEvent(listener) {
-		this.listeners.add(listener);
-		return () => this.listeners.delete(listener);
-	}
-	/** Per-path debounce: a change to file B never cancels a pending reload for file A. */
-	scheduleChange(filePath) {
-		const existing = this.debounceTimers.get(filePath);
-		if (existing) clearTimeout(existing);
-		const timer = setTimeout(() => {
-			this.debounceTimers.delete(filePath);
-			this.handleChange(filePath);
-		}, this.debounceMs);
-		this.debounceTimers.set(filePath, timer);
-	}
-	async handleChange(filePath) {
-		try {
-			if (filePath.endsWith("studio.config.ts")) {
-				await this.templateLoader.reloadAll();
-				this.emit({ type: "full" });
-				return;
-			}
-			const templateId = FileWatcher.extractTemplateId(filePath);
-			if (!templateId) {
-				await this.templateLoader.reloadAll();
-				this.emit({ type: "full" });
-				return;
-			}
-			const info = await this.templateLoader.reloadTemplate(templateId);
-			if (info?.status === "error") {
-				this.emit({
-					error: new Error(info.errorMessage ?? "Unknown template error"),
-					templateId,
-					type: "template-error"
-				});
-				return;
-			}
-			this.emit({
-				templateId,
-				type: "template"
-			});
-		} catch (error) {
-			const normalizedError = error instanceof Error ? error : new Error(String(error));
-			this.emit({
-				error: normalizedError,
-				type: "template-error"
-			});
-		}
-	}
-	/**
-	* Extracts a template id from a changed file path, supporting nested
-	* directories under templates/ (e.g. templates/social/bento.tsx ->
-	* "social/bento"). Returns null for files that don't look like a
-	* template's own .tsx entry point.
-	*/
-	static extractTemplateId(filePath) {
-		return filePath.replaceAll("\\", "/").match(/templates\/(?<templateId>.+)\.tsx$/u)?.groups?.templateId ?? null;
-	}
-	emit(event) {
-		for (const listener of this.listeners) try {
-			listener(event);
-		} catch (error) {
-			logError(ErrorCode.INTERNAL_ERROR, "Listener threw during file-watch event dispatch", {
-				error: String(error),
-				eventType: event.type
-			});
-		}
-	}
-};
-var TemplateConfigError = class extends Error {
-	issues;
-	constructor(message, issues) {
-		super(message);
-		this.name = "TemplateConfigError";
-		this.issues = issues;
-	}
-};
-function validateTemplateModule(mod, templateId) {
-	const candidate = mod;
-	if (!candidate || typeof candidate.default !== "function") throw new Error(`Template "${templateId}" must have a default export that is a component function.`);
-	if (!isZodObject(candidate.propsSchema)) throw new Error(`Template "${templateId}" must export a "propsSchema" that is a z.object({...}) describing its props.`);
-	return candidate;
-}
-function summarizeZodIssues(issues) {
-	return issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-}
-const { resolve } = path;
-var TemplateLoader = class TemplateLoader {
-	rootDir;
-	configPath;
-	viteServer = null;
-	runner = null;
-	config = null;
-	templates = /* @__PURE__ */ new Map();
-	started = false;
-	constructor(rootDir) {
-		this.rootDir = rootDir;
-		this.configPath = resolve(rootDir, "studio.config.ts");
-	}
-	/**
-	* Boots the Vite SSR pipeline. Must be called once before load/reload
-	* methods are used. Cheap to call once per `studio dev` session; not
-	* meant to be re-created per reload (that defeats the point of the
-	* module cache).
-	*/
-	async start() {
-		if (this.started) return;
-		this.viteServer = await createServer({
-			mode: "development",
-			optimizeDeps: { noDiscovery: true },
-			plugins: [react()],
-			root: this.rootDir,
-			server: {
-				hmr: false,
-				middlewareMode: true
-			},
-			ssr: { optimizeDeps: { include: ["zod"] } }
-		});
-		const nodeServer = new ViteNodeServer(this.viteServer);
-		installSourcemapsSupport({ getSourceMap: (source) => nodeServer.getSourceMap(source) });
-		this.runner = new ViteNodeRunner({
-			fetchModule: (id) => nodeServer.fetchModule(id),
-			resolveId: (id, importer) => nodeServer.resolveId(id, importer),
-			root: this.viteServer.config.root
-		});
-		this.started = true;
-	}
-	async stop() {
-		await this.viteServer?.close();
-		this.started = false;
-		this.viteServer = null;
-		this.runner = null;
-	}
-	async loadConfig() {
-		this.assertStarted();
-		const raw = await this.importFresh(this.configPath);
-		const candidate = raw.default ?? raw;
-		const parsed = studioConfigSchema.safeParse(candidate);
-		if (!parsed.success) throw new TemplateConfigError(`studio.config.ts is invalid: ${summarizeZodIssues(parsed.error.issues)}`, parsed.error.issues);
-		this.config = parsed.data;
-		return this.config;
-	}
-	async getConfig() {
-		if (!this.config) return this.loadConfig();
-		return this.config;
-	}
-	/**
-	* Loads the config and registers + loads every template declared in it.
-	* A failure in one template does not prevent the others from loading.
-	*/
-	async loadAll() {
-		const config = await this.loadConfig();
-		this.templates.clear();
-		for (const [id, entry] of Object.entries(config.templates)) {
-			const modulePath = resolve(this.rootDir, `${entry.componentPath}.tsx`);
-			this.templates.set(id, {
-				contentHash: "",
-				description: entry.description ?? "",
-				id,
-				modulePath,
-				state: null
-			});
-		}
-		await Promise.all([...this.templates.keys()].map((id) => this.loadOne(id)));
-		return this.getAllTemplateInfo();
-	}
-	/**
-	* (Re)loads a single template by id. Used by the file watcher when one
-	* template file changes -- does not touch any other template's state.
-	*/
-	async reloadTemplate(id) {
-		const entry = this.templates.get(id);
-		if (!entry) return null;
-		await this.loadOne(id);
-		return TemplateLoader.toTemplateInfo(entry);
-	}
-	/**
-	* Full reload: config + every template. Used when studio.config.ts
-	* itself changes, since template registration may have changed.
-	*/
-	async reloadAll() {
-		this.invalidateModule(this.configPath);
-		return this.loadAll();
-	}
-	getTemplateModule(id) {
-		const entry = this.templates.get(id);
-		if (!entry || !entry.state || entry.state.status === "error") return null;
-		return entry.state.module;
-	}
-	getTemplateInfo(id) {
-		const entry = this.templates.get(id);
-		return entry ? TemplateLoader.toTemplateInfo(entry) : null;
-	}
-	getAllTemplateInfo() {
-		return [...this.templates.values()].map((entry) => TemplateLoader.toTemplateInfo(entry));
-	}
-	/**
-	* Loads any file (not just templates) through the same vite-node SSR
-	* pipeline used for templates -- e.g. locale JSON files. Reuses the
-	* already-running Vite server rather than spinning up a second one, and
-	* gets the same leak-free cache invalidation as template loading.
-	*
-	* Returns the module's default export if present, otherwise the module
-	* namespace itself (matches how `import x.json` typically shapes up).
-	*/
-	async loadDataModule(filePath) {
-		const raw = await this.importFresh(filePath);
-		return raw.default ?? raw;
-	}
-	/** Forces a fresh read on the next loadDataModule/template load for this path. */
-	invalidateDataModule(filePath) {
-		this.invalidateModule(filePath);
-	}
-	async loadOne(id) {
-		const entry = this.templates.get(id);
-		if (!entry) return;
-		try {
-			const content = await readFile(entry.modulePath, "utf-8");
-			entry.contentHash = createHash("sha256").update(content).digest("hex").slice(0, 16);
-			this.invalidateModule(entry.modulePath);
-			entry.state = {
-				module: validateTemplateModule(await this.importFresh(entry.modulePath), id),
-				status: "ok"
-			};
-		} catch (error) {
-			console.error(`[template-loader] Failed to load template "${id}":`, error);
-			entry.state = {
-				error: error instanceof Error ? error : new Error(String(error)),
-				status: "error"
-			};
-		}
-	}
-	importFresh(modulePath) {
-		if (!this.runner) throw new Error("TemplateLoader.start() must be called before loading modules.");
-		return this.runner.executeFile(modulePath);
-	}
-	invalidateModule(modulePath) {
-		if (!this.runner) return;
-		const id = pathToFileURL(modulePath).pathname;
-		this.runner.moduleCache.deleteByModuleId(id);
-		this.runner.moduleCache.delete(modulePath);
-	}
-	static toTemplateInfo(entry) {
-		if (!entry.state) return {
-			contentHash: entry.contentHash,
-			description: entry.description,
-			errorMessage: "Not loaded yet",
-			id: entry.id,
-			propsSchema: {},
-			status: "error"
-		};
-		if (entry.state.status === "error") return {
-			contentHash: entry.contentHash,
-			description: entry.description,
-			errorMessage: entry.state.error.message,
-			id: entry.id,
-			propsSchema: {},
-			status: "error"
-		};
-		return {
-			contentHash: entry.contentHash,
-			description: entry.description,
-			id: entry.id,
-			propsSchema: zodToJsonSchemaShape(entry.state.module.propsSchema),
-			status: "ok"
-		};
-	}
-	assertStarted() {
-		if (!this.started || !this.runner) throw new Error("TemplateLoader.start() must be called before use.");
-	}
-};
-const renderRequestSchema = z.object({
-	locale: z.string().optional(),
-	preset: z.string().optional(),
-	props: z.unknown(),
-	templateId: z.string().min(1)
-});
-const measureRequestSchema = z.object({
-	props: z.unknown(),
-	templateId: z.string().min(1)
-});
-/**
-* Merges locale translations into already-validated props. Loads the
-* locale JSON through TemplateLoader's vite-node pipeline (the same
-* leak-free, explicitly-invalidated module cache used for templates)
-* rather than a raw `import(...)?t=Date.now()`, which would reproduce the
-* exact unbounded module-registry leak that was fixed for template
-* loading.
-*
-* Unlike the original, failures are NOT swallowed: a missing or malformed
-* locale file is a real error the caller should see, not a silent
-* fallback to default-language props (silently shipping the wrong
-* language is a worse outcome than a clear 400).
-*/
-const applyLocale = async (templateLoader, rootDir, locale, props) => {
-	const localePath = `${rootDir}/locales/${locale}.json`;
-	const translations = await templateLoader.loadDataModule(localePath);
-	const merged = {
-		...props,
-		locale
-	};
-	for (const [key, value] of Object.entries(translations)) if (Array.isArray(value) && Array.isArray(merged[key])) merged[key] = value;
-	else if (typeof value === "string" && typeof merged[key] === "string") merged[key] = value;
-	return merged;
-};
-const createDevServer = async (options) => {
-	const { rootDir, port, cacheDir, webUiDist: _webUiDist } = options;
-	const templateLoader = new TemplateLoader(rootDir);
-	const fileWatcher = new FileWatcher(rootDir, templateLoader);
-	const renderCache = new RenderCache({ cacheDir: cacheDir ?? path.join(rootDir, ".studio-cache") });
-	await renderCache.init();
-	await templateLoader.start();
-	await templateLoader.loadAll();
-	fileWatcher.start();
-	const app = new Hono();
-	app.onError(errorHandler);
-	app.use("*", cors({
-		credentials: true,
-		origin: ["http://localhost:5173", `http://localhost:${port}`]
-	}));
-	app.use("*", logger());
-	app.get("/events", (c) => streamSSE(c, async (s) => {
-		const unsubscribe = fileWatcher.onEvent((event) => {
-			s.writeSSE({
-				data: JSON.stringify(event),
-				event: "reload"
-			});
-		});
-		s.onAbort(unsubscribe);
-		await s.writeSSE({
-			data: "{}",
-			event: "connected"
-		});
-		while (!c.req.raw.signal.aborted) {
-			await s.write(": keepalive\n\n");
-			await s.sleep(15e3);
-		}
-	}));
-	app.get("/templates", (c) => c.json(templateLoader.getAllTemplateInfo()));
-	app.get("/presets", async (c) => {
-		const config = await templateLoader.getConfig();
-		return c.json(config.presets);
-	});
-	app.get("/locales", async (c) => {
-		const config = await templateLoader.getConfig();
-		return c.json(config.locales ?? []);
-	});
-	app.get("/config", async (c) => {
-		const config = await templateLoader.getConfig();
-		return c.json({
-			defaultPreset: config.defaultPreset,
-			locales: config.locales,
-			outDir: config.outDir,
-			presets: config.presets
-		});
-	});
-	app.post("/render", async (c) => {
-		const parsedBody = renderRequestSchema.safeParse(await c.req.json());
-		if (!parsedBody.success) {
-			logWarn("Invalid render request body", { issues: parsedBody.error.issues });
-			return c.json({
-				error: "Invalid request body",
-				issues: parsedBody.error.issues
-			}, 400);
-		}
-		const { templateId, props, preset: presetId, locale } = parsedBody.data;
-		const templateInfo = templateLoader.getTemplateInfo(templateId);
-		if (!templateInfo) {
-			logWarn("Render template not found", { templateId });
-			return c.json({ error: `Template "${templateId}" not found` }, 404);
-		}
-		if (templateInfo.status === "error") {
-			logWarn("Render template load error", {
-				errorMessage: templateInfo.errorMessage,
-				templateId
-			});
-			return c.json({ error: `Template "${templateId}" failed to load: ${templateInfo.errorMessage}` }, 422);
-		}
-		const templateModule = templateLoader.getTemplateModule(templateId);
-		if (!templateModule) return c.json({ error: `Template "${templateId}" module unavailable` }, 500);
-		const config = await templateLoader.getConfig();
-		const preset = presetId ? config.presets.find((p) => p.id === presetId) : config.presets.find((p) => p.id === config.defaultPreset);
-		if (!preset) {
-			logWarn("Render preset not found", { presetId: presetId ?? config.defaultPreset });
-			return c.json({ error: `Preset "${presetId ?? config.defaultPreset}" not found` }, 404);
-		}
-		const parsed = templateModule.propsSchema.safeParse(props);
-		if (!parsed.success) {
-			logWarn("Invalid render props", {
-				issues: parsed.error.issues,
-				templateId
-			});
-			return c.json({
-				error: "Invalid props",
-				issues: parsed.error.issues
-			}, 400);
-		}
-		const validatedProps = parsed.data;
-		let resolvedProps;
-		if (locale) try {
-			resolvedProps = await applyLocale(templateLoader, rootDir, locale, validatedProps);
-		} catch (error) {
-			const message = error instanceof Error ? error.message : "Failed to load locale";
-			logWarn("Render locale load failed", {
-				locale,
-				message
-			});
-			return c.json({ error: `Locale "${locale}": ${message}` }, 400);
-		}
-		else resolvedProps = validatedProps;
-		const propsJSON = JSON.stringify(resolvedProps);
-		const pixelKey = RenderCache.createPixelCacheKey({
-			height: preset.height,
-			propsJSON,
-			templateContentHash: templateInfo.contentHash,
-			width: preset.width
-		});
-		const cached = await renderCache.getPixels(pixelKey);
-		if (cached) return new Response(new Uint8Array(cached), { headers: {
-			"Cache-Control": "public, max-age=31536000, immutable",
-			"Content-Type": "image/png",
-			"X-Cache": "hit"
-		} });
-		const compileKey = RenderCache.createCompileCacheKey({
-			propsJSON,
-			templateContentHash: templateInfo.contentHash,
-			templateId
-		});
-		let compiled = renderCache.getCompiled(compileKey);
-		if (!compiled) {
-			const Component = templateModule.default;
-			compiled = await compileTemplate(createElement(Component, resolvedProps));
-			renderCache.setCompiledWithContentHash(compileKey, templateInfo.contentHash, compiled);
-		}
-		const output = await renderToPixels(compiled, {
-			height: preset.height,
-			width: preset.width
-		});
-		await renderCache.setPixels(pixelKey, output.bytes, preset.width, preset.height);
-		return new Response(new Uint8Array(output.bytes), { headers: {
-			"Cache-Control": "public, max-age=31536000, immutable",
-			"Content-Type": "image/png",
-			"X-Cache": "miss"
-		} });
-	});
-	app.post("/measure", async (c) => {
-		const parsedBody = measureRequestSchema.safeParse(await c.req.json());
-		if (!parsedBody.success) {
-			logWarn("Invalid measure request body", { issues: parsedBody.error.issues });
-			return c.json({
-				error: "Invalid request body",
-				issues: parsedBody.error.issues
-			}, 400);
-		}
-		const { templateId, props } = parsedBody.data;
-		const templateInfo = templateLoader.getTemplateInfo(templateId);
-		if (!templateInfo) {
-			logWarn("Measure template not found", { templateId });
-			return c.json({ error: `Template "${templateId}" not found` }, 404);
-		}
-		if (templateInfo.status === "error") {
-			logWarn("Measure template load error", {
-				errorMessage: templateInfo.errorMessage,
-				templateId
-			});
-			return c.json({ error: `Template "${templateId}" failed to load: ${templateInfo.errorMessage}` }, 422);
-		}
-		const templateModule = templateLoader.getTemplateModule(templateId);
-		if (!templateModule) return c.json({ error: `Template "${templateId}" module unavailable` }, 500);
-		const parsed = templateModule.propsSchema.safeParse(props);
-		if (!parsed.success) {
-			logWarn("Invalid measure props", {
-				issues: parsed.error.issues,
-				templateId
-			});
-			return c.json({
-				error: "Invalid props",
-				issues: parsed.error.issues
-			}, 400);
-		}
-		const validatedProps = parsed.data;
-		const propsJSON = JSON.stringify(validatedProps);
-		const compileKey = RenderCache.createCompileCacheKey({
-			propsJSON,
-			templateContentHash: templateInfo.contentHash,
-			templateId
-		});
-		let compiled = renderCache.getCompiled(compileKey);
-		if (!compiled) {
-			const Component = templateModule.default;
-			compiled = await compileTemplate(createElement(Component, validatedProps));
-			renderCache.setCompiledWithContentHash(compileKey, templateInfo.contentHash, compiled);
-		}
-		const measured = await measureTemplate(compiled);
-		return c.json({
-			height: measured.height,
-			width: measured.width
-		});
-	});
-	app.get("/cache/stats", (c) => c.json(renderCache.stats()));
-	app.post("/cache/clean", async (c) => {
-		const result = await renderCache.clean();
-		return c.json(result);
-	});
-	const close = async () => {
-		await fileWatcher.stop();
-		await templateLoader.stop();
-		renderCache.close();
-	};
-	return {
-		app,
-		close,
-		fileWatcher,
-		port,
-		templateLoader
-	};
-};
-//#endregion
-export { createDevServer };