@ox-content/code-play 3.0.0-alpha.10 → 3.0.0-alpha.12

package/dist/plugin2.mjs

@@ -1,6 +1,6 @@
 import { f as resolveCodePlayOptions, h as resolveLanguage, i as escapeAttribute, n as encodePayload, o as DEFAULT_ENDPOINTS, r as decodeHtml, s as DEFAULT_VIEWERS, t as decodePayload, u as DEV_TYPECHECK_PATH } from "./payload.mjs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/authoring.ts
@@ -48,6 +48,7 @@ function parseCodePlayAttributes(attrs) {
 			options.viewers = parseViewers(value);
 			continue;
 		}
+		if (applyProjectAttribute(options, name, value)) continue;
 		if (name.startsWith("config-")) options.config[configKeyFromAttribute(name.slice(7))] = coerceOptionValue(value);
 	}
 	return options;
@@ -118,9 +119,70 @@ function applyPlayOption(options, rawName, value) {
 		options.viewers = parseViewers(value);
 		return;
 	}
+	if (applyProjectMeta(options, rawName, value)) return;
 	const configKey = name.startsWith("play-config:") || name.startsWith("play-config.") ? rawName.slice(12) : name.startsWith("play-") ? rawName.slice(5) : "";
 	if (configKey) options.config[configKey] = coerceOptionValue(value);
 }
+function applyProjectMeta(options, rawName, value) {
+	switch (rawName.toLowerCase()) {
+		case "play-project":
+		case "play-sandbox":
+		case "play-provider":
+			ensureProject(options, value);
+			return true;
+		case "play-entry":
+			ensureProject(options).entry = value;
+			return true;
+		case "play-file":
+			ensureProject(options).file = value;
+			return true;
+		case "play-files":
+			ensureProject(options).files.push(...splitList(value));
+			return true;
+		case "play-project-url":
+		case "play-open-url":
+			ensureProject(options).openUrl = value;
+			return true;
+		case "play-fallback-url":
+			ensureProject(options).fallbackUrl = value;
+			return true;
+		default: return false;
+	}
+}
+function applyProjectAttribute(options, name, value) {
+	switch (name) {
+		case "project":
+		case "sandbox":
+		case "provider":
+			ensureProject(options, value);
+			return true;
+		case "entry":
+			ensureProject(options).entry = value;
+			return true;
+		case "file":
+			ensureProject(options).file = value;
+			return true;
+		case "files":
+			ensureProject(options).files.push(...splitList(value));
+			return true;
+		case "project-url":
+		case "open-url":
+			ensureProject(options).openUrl = value;
+			return true;
+		case "fallback-url":
+			ensureProject(options).fallbackUrl = value;
+			return true;
+		default: return false;
+	}
+}
+function ensureProject(options, provider = "external") {
+	options.project ??= {
+		provider,
+		files: []
+	};
+	if (provider && options.project.provider === "external") options.project.provider = provider;
+	return options.project;
+}
 function readTokenPair(token) {
 	const index = token.indexOf("=");
 	if (index === -1) return;
@@ -155,6 +217,9 @@ function parseViewers(value) {
 	}
 	return Object.keys(viewers).length > 0 ? viewers : void 0;
 }
+function splitList(value) {
+	return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
 function coerceOptionValue(value) {
 	if (value === "true") return true;
 	if (value === "false") return false;
@@ -231,7 +296,8 @@ function parsePlayFences(source) {
 			config: options.config,
 			ui: options.ui,
 			viewers: options.viewers,
-			timeoutMs: options.timeoutMs
+			timeoutMs: options.timeoutMs,
+			project: options.project
 		};
 	});
 }
@@ -275,7 +341,8 @@ function parseCodePlayTags(source) {
 			config: options.config,
 			ui: options.ui,
 			viewers: options.viewers,
-			timeoutMs: options.timeoutMs
+			timeoutMs: options.timeoutMs,
+			project: options.project
 		});
 	}
 	return tags;
@@ -300,8 +367,153 @@ function stripIndent(value) {
 	return lines.map((line) => line.slice(indent)).join("\n");
 }
 //#endregion
+//#region src/project-sandbox.ts
+const PROJECT_SANDBOX_ADAPTERS = {
+	stackblitz: adapter("stackblitz", "StackBlitz", "browser"),
+	codesandbox: adapter("codesandbox", "CodeSandbox", "browser"),
+	webcontainer: adapter("webcontainer", "WebContainer", "node"),
+	external: adapter("external", "External sandbox", "external")
+};
+function projectSandboxFromPayloadInput(input) {
+	if (!input.project) return;
+	const warnings = [...input.warnings ?? []];
+	const adapter = resolveProjectSandboxAdapter(input.project.provider, warnings);
+	const sourceFile = normalizeProjectPath(input.project.file, warnings, "source file");
+	const entry = normalizeProjectPath(input.project.entry, warnings, "entry path");
+	const primary = {
+		path: sourceFile ?? entry ?? defaultProjectFile(input.language, input.definition),
+		code: input.code
+	};
+	const files = mergeProjectFiles([primary, ...input.files ?? []]);
+	const openUrl = safeProjectUrl(input.project.openUrl, adapter.provider, warnings);
+	const fallbackUrl = safeProjectUrl(input.project.fallbackUrl, adapter.provider, warnings);
+	return adapter.resolve({
+		provider: input.project.provider,
+		entry: entry ?? primary.path,
+		files,
+		openUrl,
+		fallbackUrl,
+		warnings
+	});
+}
+function normalizeProjectPath(value, warnings = [], label = "file path") {
+	const trimmed = value?.trim();
+	if (!trimmed) return;
+	const normalized = trimmed.replace(/^\.\//, "");
+	if (normalized.startsWith("/") || normalized.includes("\\") || normalized.includes("\0") || normalized.split("/").some((part) => part === "" || part === "." || part === "..") || /^[a-z]+:/i.test(normalized)) {
+		warnings.push(`Skipped unsafe project ${label}: ${trimmed}`);
+		return;
+	}
+	if (normalized.length > 256) {
+		warnings.push(`Skipped long project ${label}: ${trimmed}`);
+		return;
+	}
+	return normalized;
+}
+function projectSandboxProviderLabel(provider) {
+	return PROJECT_SANDBOX_ADAPTERS[provider].label;
+}
+function adapter(provider, label, target) {
+	return {
+		provider,
+		label,
+		target,
+		resolve(input) {
+			return compactProjectSandbox({
+				provider,
+				label,
+				target,
+				entry: input.entry,
+				files: input.files,
+				openUrl: input.openUrl,
+				fallbackUrl: input.fallbackUrl,
+				warnings: input.warnings
+			});
+		}
+	};
+}
+function defaultProjectFile(language, definition) {
+	if (definition?.framework === "vue") return "src/App.vue";
+	if (definition?.framework === "react" || definition?.framework === "solid") return "src/App.tsx";
+	if (definition?.framework === "svelte") return "src/App.svelte";
+	switch (language) {
+		case "javascript": return "index.js";
+		case "typescript": return "index.ts";
+		case "go": return "main.go";
+		case "rust": return "src/main.rs";
+		default: return "snippet.txt";
+	}
+}
+function resolveProjectSandboxAdapter(rawProvider, warnings) {
+	switch (rawProvider.trim().toLowerCase()) {
+		case "stackblitz":
+		case "stack-blitz":
+		case "sb": return PROJECT_SANDBOX_ADAPTERS.stackblitz;
+		case "codesandbox":
+		case "code-sandbox":
+		case "csb": return PROJECT_SANDBOX_ADAPTERS.codesandbox;
+		case "webcontainer":
+		case "web-container": return PROJECT_SANDBOX_ADAPTERS.webcontainer;
+		case "external":
+		case "": return PROJECT_SANDBOX_ADAPTERS.external;
+		default:
+			warnings.push(`Unknown project sandbox provider: ${rawProvider}`);
+			return PROJECT_SANDBOX_ADAPTERS.external;
+	}
+}
+function mergeProjectFiles(files) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const file of files) merged.set(file.path, file);
+	return [...merged.values()];
+}
+function safeProjectUrl(value, provider, warnings) {
+	if (!value) return;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		warnings.push(`Skipped invalid project URL: ${value}`);
+		return;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") {
+		warnings.push(`Skipped non-http project URL: ${value}`);
+		return;
+	}
+	if (url.username || url.password) {
+		warnings.push(`Skipped project URL with credentials: ${url.origin}`);
+		return;
+	}
+	if (!providerAllowsHost(provider, url.hostname)) {
+		warnings.push(`Skipped ${provider} project URL on unexpected host: ${url.hostname}`);
+		return;
+	}
+	return url.href;
+}
+function providerAllowsHost(provider, host) {
+	if (provider === "external") return true;
+	const normalized = host.toLowerCase();
+	return {
+		stackblitz: ["stackblitz.com"],
+		codesandbox: ["codesandbox.io", "csb.app"],
+		webcontainer: ["webcontainers.io", "webcontainer.io"]
+	}[provider].some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
+}
+function compactProjectSandbox(project) {
+	const next = {
+		provider: project.provider,
+		label: project.label,
+		target: project.target,
+		files: project.files
+	};
+	if (project.entry) next.entry = project.entry;
+	if (project.openUrl) next.openUrl = project.openUrl;
+	if (project.fallbackUrl) next.fallbackUrl = project.fallbackUrl;
+	if (project.warnings?.length) next.warnings = project.warnings;
+	return next;
+}
+//#endregion
 //#region src/payload-factory.ts
-function payloadFromFence(fence, options) {
+function payloadFromFence(fence, options, context = {}) {
 	const definition = resolveLanguage(fence.language);
 	const enabled = definition ? options.languages.get(definition.id) : void 0;
 	const payload = {
@@ -326,6 +538,15 @@ function payloadFromFence(fence, options) {
 		endpoints: options.endpoints
 	};
 	if (enabled?.endpoint) payload.endpoint = enabled.endpoint;
+	const project = projectSandboxFromPayloadInput({
+		language: payload.language,
+		code: payload.code,
+		definition,
+		project: fence.project,
+		files: context.files,
+		warnings: context.warnings
+	});
+	if (project) payload.project = project;
 	return payload;
 }
 /** TypeScript typecheck in the browser needs a reachable endpoint; hide the dead button otherwise. */
@@ -369,7 +590,7 @@ function upgradeCodePlayTags(html, options) {
 		const definition = resolveLanguage(language);
 		const endpoints = options.endpoints ?? DEFAULT_ENDPOINTS;
 		const playOptions = parseCodePlayAttributes(attrs);
-		return wrapWidget(options.encodePayload({
+		const payloadValue = {
 			language: definition?.id ?? language,
 			code,
 			title: playOptions.title,
@@ -388,7 +609,15 @@ function upgradeCodePlayTags(html, options) {
 			ui: playOptions.ui ?? "default",
 			timeoutMs: playOptions.timeoutMs ?? 1e4,
 			endpoints
-		}), `<pre><code class="language-${escapeAttribute(language)}">${body}</code></pre>`);
+		};
+		const project = projectSandboxFromPayloadInput({
+			language: payloadValue.language,
+			code,
+			definition,
+			project: playOptions.project
+		});
+		if (project) payloadValue.project = project;
+		return wrapWidget(options.encodePayload(payloadValue), `<pre><code class="language-${escapeAttribute(language)}">${body}</code></pre>`);
 	});
 }
 function wrapMatchingFences(html, matches) {
@@ -445,6 +674,111 @@ function aliasesEqual(left, right) {
 	return left.toLowerCase() === right.toLowerCase();
 }
 //#endregion
+//#region src/project-files.ts
+const DEFAULT_MAX_FILES = 32;
+const DEFAULT_MAX_BYTES = 262144;
+function collectProjectFiles(project, context = {}) {
+	const warnings = [];
+	if (!project?.files.length) return {
+		files: [],
+		warnings
+	};
+	if (!context.documentPath) {
+		warnings.push("Skipped project files because the Markdown source path is unavailable.");
+		return {
+			files: [],
+			warnings
+		};
+	}
+	const documentDir = path.dirname(context.documentPath);
+	const sourceRoot = path.resolve(context.sourceRoot ?? documentDir);
+	const realSourceRoot = realpathIfExists(sourceRoot) ?? sourceRoot;
+	const files = [];
+	for (const requested of project.files) {
+		if (files.length >= (context.maxFiles ?? DEFAULT_MAX_FILES)) {
+			warnings.push(`Skipped project file after ${files.length} files: ${requested}`);
+			continue;
+		}
+		const safePath = normalizeProjectPath(requested, warnings);
+		if (!safePath) continue;
+		const absolute = path.resolve(documentDir, safePath);
+		if (!pathInside(absolute, sourceRoot)) {
+			warnings.push(`Skipped project file outside source root: ${safePath}`);
+			continue;
+		}
+		const realAbsolute = realpathIfExists(absolute);
+		if (!realAbsolute) {
+			warnings.push(`Skipped missing project file: ${safePath}`);
+			continue;
+		}
+		if (!pathInside(realAbsolute, realSourceRoot)) {
+			warnings.push(`Skipped project file outside real source root: ${safePath}`);
+			continue;
+		}
+		const stat = statSync(realAbsolute);
+		if (!stat.isFile()) {
+			warnings.push(`Skipped non-file project path: ${safePath}`);
+			continue;
+		}
+		if (stat.size > (context.maxBytes ?? DEFAULT_MAX_BYTES)) {
+			warnings.push(`Skipped large project file: ${safePath}`);
+			continue;
+		}
+		files.push({
+			path: safePath,
+			code: readFileSync(realAbsolute, "utf8")
+		});
+	}
+	return {
+		files,
+		warnings
+	};
+}
+function realpathIfExists(file) {
+	if (!existsSync(file)) return;
+	return realpathSync(file);
+}
+function pathInside(file, root) {
+	const relative = path.relative(root, file);
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+//#endregion
+//#region src/plugin-paths.ts
+const MARKDOWN_RE = /\.(?:md|markdown|mdx)(?:$|\?)/i;
+function cleanMarkdownPath(id, root) {
+	const file = id.split("?")[0];
+	if (!file || file.startsWith("\0")) return;
+	return path.isAbsolute(file) ? file : path.resolve(root, file);
+}
+function guessHtmlPath(file, srcDir, outDir) {
+	const relative = path.relative(srcDir, file).replace(/\.(?:md|markdown|mdx)$/i, "");
+	return [path.join(outDir, `${relative}.html`), path.join(outDir, relative, "index.html")].find((candidate) => existsSync(candidate));
+}
+function normalizeBase(base) {
+	if (!base || base === "/") return "/";
+	return base.endsWith("/") ? base : `${base}/`;
+}
+function sourceRoot(root, resolved) {
+	return path.resolve(root, resolved.srcDir ?? "docs");
+}
+function urlToMarkdown(urlPath, root, srcDir, base) {
+	let relative = urlPath;
+	if (base !== "/" && relative.startsWith(base)) relative = relative.slice(base.length);
+	relative = relative.replace(/^\//, "").replace(/\.html$/, "");
+	if (!relative || relative.includes("..")) return;
+	return [path.resolve(root, srcDir, `${relative}.md`), path.resolve(root, srcDir, relative, "index.md")].find((candidate) => existsSync(candidate));
+}
+function walkFiles(dir) {
+	const entries = readdirSync(dir);
+	const files = [];
+	for (const entry of entries) {
+		const full = path.join(dir, entry);
+		if (statSync(full).isDirectory()) files.push(...walkFiles(full));
+		else files.push(full);
+	}
+	return files;
+}
+//#endregion
 //#region src/plugin-client.ts
 const CLIENT_FILE_CANDIDATES = [
 	"browser.mjs",
@@ -555,7 +889,6 @@ function writeJson(res, status, body) {
 //#region src/plugin.ts
 const VIRTUAL_ID = "virtual:ox-content/code-play";
 const RESOLVED_VIRTUAL = `\0${VIRTUAL_ID}`;
-const MARKDOWN_RE = /\.(?:md|markdown|mdx)(?:$|\?)/i;
 function codePlay(options = {}) {
 	const resolved = resolveCodePlayOptions(options);
 	const explicitTypecheck = options.endpoints?.typecheck;
@@ -610,7 +943,7 @@ function codePlay(options = {}) {
 			const rewritten = rewritePlayFences(code, (fence) => {
 				const definition = resolveLanguage(fence.language);
 				if (!definition || !resolved.languages.has(definition.id)) return null;
-				return encodePayload(payloadFromFence(fence, resolved));
+				return encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, cleanMarkdownPath(id, root), sourceRoot(root, resolved))));
 			});
 			if (rewritten === code) return null;
 			needsClientAsset = true;
@@ -680,6 +1013,7 @@ function enhanceHtmlForUrl(urlPath, html, root, resolved, enhance) {
 	const markdownPath = urlToMarkdown(urlPath, root, resolved.srcDir ?? "docs", resolved.base);
 	if (!markdownPath || !existsSync(markdownPath)) return;
 	const source = readFileSync(markdownPath, "utf8");
+	const srcRoot = sourceRoot(root, resolved);
 	const fences = [...parsePlayFences(source), ...parseCodePlayTags(source)].filter((fence) => {
 		const definition = resolveLanguage(fence.language);
 		return Boolean(definition && resolved.languages.has(definition.id));
@@ -688,16 +1022,9 @@ function enhanceHtmlForUrl(urlPath, html, root, resolved, enhance) {
 	return enhancePlayHtml(html, enhance(fences.map((fence) => ({
 		language: fence.language,
 		code: fence.code,
-		payload: encodePayload(payloadFromFence(fence, resolved))
+		payload: encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, markdownPath, srcRoot)))
 	}))));
 }
-function urlToMarkdown(urlPath, root, srcDir, base) {
-	let relative = urlPath;
-	if (base !== "/" && relative.startsWith(base)) relative = relative.slice(base.length);
-	relative = relative.replace(/^\//, "").replace(/\.html$/, "");
-	if (!relative || relative.includes("..")) return;
-	return [path.resolve(root, srcDir, `${relative}.md`), path.resolve(root, srcDir, relative, "index.md")].find((candidate) => existsSync(candidate));
-}
 function mountProxies(server, rustUrl, goUrl) {
 	server.middlewares.use("/__ox-code-play/rust", (req, res) => {
 		proxy(req, res, rustUrl, "application/json");
@@ -725,7 +1052,7 @@ async function enhanceWrittenPages(srcDir, outDir, resolved, enhance) {
 		const enhanced = enhancePlayHtml(html, enhance(fences.map((fence) => ({
 			language: fence.language,
 			code: fence.code,
-			payload: encodePayload(payloadFromFence(fence, resolved))
+			payload: encodePayload(payloadFromFence(fence, resolved, projectContextForFence(fence, file, srcDir)))
 		}))));
 		if (enhanced !== html) {
 			await writeFile(htmlPath, enhanced);
@@ -734,25 +1061,14 @@ async function enhanceWrittenPages(srcDir, outDir, resolved, enhance) {
 	}
 	return enhancedAny;
 }
-function guessHtmlPath(file, srcDir, outDir) {
-	const relative = path.relative(srcDir, file).replace(/\.(?:md|markdown|mdx)$/i, "");
-	return [path.join(outDir, `${relative}.html`), path.join(outDir, relative, "index.html")].find((candidate) => existsSync(candidate));
-}
-function walkFiles(dir) {
-	const entries = readdirSync(dir);
-	const files = [];
-	for (const entry of entries) {
-		const full = path.join(dir, entry);
-		if (statSync(full).isDirectory()) files.push(...walkFiles(full));
-		else files.push(full);
-	}
-	return files;
-}
-function normalizeBase(base) {
-	if (!base || base === "/") return "/";
-	return base.endsWith("/") ? base : `${base}/`;
+function projectContextForFence(fence, documentPath, srcRoot) {
+	if (!fence.project) return {};
+	return collectProjectFiles(fence.project, {
+		documentPath,
+		sourceRoot: srcRoot
+	});
 }
 //#endregion
-export { parsePlayFences as a, parseCodePlayTags as i, enhanceGeneratedModule as n, rewritePlayFences as o, enhancePlayHtml as r, stripPlayMeta as s, codePlay as t };
+export { normalizeProjectPath as a, parseCodePlayTags as c, stripPlayMeta as d, PROJECT_SANDBOX_ADAPTERS as i, parsePlayFences as l, enhanceGeneratedModule as n, projectSandboxFromPayloadInput as o, enhancePlayHtml as r, projectSandboxProviderLabel as s, codePlay as t, rewritePlayFences as u };
 
 //# sourceMappingURL=plugin2.mjs.map