@open-slide/core 0.0.9 → 0.0.11

package/dist/{build-pqF4W1Yi.js → build-DHiRlpjn.js}

@@ -1,4 +1,4 @@
-import { createViteConfig } from "./config-CtwxMYv9.js";
+import { createViteConfig } from "./config-LZM903FE.js";
 import path from "node:path";
 import { build as build$1, mergeConfig } from "vite";
 

package/dist/cli/bin.js

@@ -22,15 +22,15 @@ async function run(argv) {
 	const program = new Command();
 	program.name("open-slide").description("Author slides — we handle the Vite/React stack.").version(version, "-v, --version", "print version").helpOption("-h, --help", "show help").showHelpAfterError(chalk.dim("(run `open-slide --help` for usage)"));
 	program.command("dev").description("Start the dev server").addOption(new Option("-p, --port <port>", "port to listen on").argParser(parsePort)).addOption(new Option("--host [host]", "expose on the network (optional host)")).option("--open", "open the browser on start").action(async (flags) => {
-		const { dev } = await import("../dev-CJX97uiy.js");
+		const { dev } = await import("../dev-B3JzCYn7.js");
 		await dev(flags);
 	});
 	program.command("build").description("Build a static site").option("--out-dir <dir>", "output directory (defaults to `dist`)").action(async (flags) => {
-		const { build } = await import("../build-pqF4W1Yi.js");
+		const { build } = await import("../build-DHiRlpjn.js");
 		await build(flags);
 	});
 	program.command("preview").description("Preview the production build").addOption(new Option("-p, --port <port>", "port to listen on").argParser(parsePort)).addOption(new Option("--host [host]", "expose on the network (optional host)")).option("--open", "open the browser on start").action(async (flags) => {
-		const { preview } = await import("../preview-IuLPcL5y.js");
+		const { preview } = await import("../preview-UikovHEt.js");
 		await preview(flags);
 	});
 	await program.parseAsync(argv, { from: "user" });

package/dist/{config-CtwxMYv9.js → config-LZM903FE.js}

@@ -312,6 +312,116 @@ function buildTextSplice(element, value) {
 	}
 	return { error: "element has complex children" };
 }
+function findImports(ast) {
+	const body = ast.program?.body ?? [];
+	const out = [];
+	for (const node of body) {
+		if (node.type !== "ImportDeclaration") continue;
+		const src = node.source?.value;
+		if (typeof src !== "string") continue;
+		const specs = node.specifiers ?? [];
+		let def = null;
+		for (const spec of specs) if (spec.type === "ImportDefaultSpecifier") {
+			const local = spec.local?.name;
+			if (typeof local === "string") {
+				def = local;
+				break;
+			}
+		}
+		out.push({
+			node,
+			source: src,
+			defaultIdent: def
+		});
+	}
+	return out;
+}
+function collectTopLevelIdentifiers(ast) {
+	const names = new Set();
+	for (const imp of findImports(ast)) {
+		if (imp.defaultIdent) names.add(imp.defaultIdent);
+		const specs = imp.node.specifiers ?? [];
+		for (const spec of specs) if (spec.type !== "ImportDefaultSpecifier") {
+			const local = spec.local?.name;
+			if (typeof local === "string") names.add(local);
+		}
+	}
+	return names;
+}
+function safeAssetIdentifier(filename, taken) {
+	const stem = filename.replace(/\.[^.]+$/, "");
+	let camel = "";
+	let upper = false;
+	for (const ch of stem) if (/[A-Za-z0-9]/.test(ch)) {
+		camel += upper ? ch.toUpperCase() : ch;
+		upper = false;
+	} else upper = camel.length > 0;
+	let base = camel;
+	if (!base || !/^[A-Za-z_$]/.test(base)) base = `asset${base.charAt(0).toUpperCase()}${base.slice(1)}` || "asset";
+	base = base.charAt(0).toLowerCase() + base.slice(1);
+	let candidate = base;
+	let i = 2;
+	while (taken.has(candidate)) {
+		candidate = `${base}${i}`;
+		i += 1;
+	}
+	return candidate;
+}
+function findJsxAttr(opening, name) {
+	const attrs = opening.attributes ?? [];
+	for (const attr of attrs) {
+		if (attr.type !== "JSXAttribute") continue;
+		const n = attr.name;
+		if (n?.type === "JSXIdentifier" && n.name === name) return attr;
+	}
+	return null;
+}
+function planAssetAttr(ast, element, attr, assetPath) {
+	const opening = element.openingElement;
+	if (!opening) return { error: "no opening element" };
+	if (!attr || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(attr)) return { error: "invalid attribute name" };
+	if (!assetPath.startsWith("./assets/")) return { error: "asset path must start with ./assets/" };
+	const imports = findImports(ast);
+	let identifier = null;
+	for (const imp of imports) if (imp.source === assetPath && imp.defaultIdent) {
+		identifier = imp.defaultIdent;
+		break;
+	}
+	let importSplice = null;
+	if (!identifier) {
+		const filename = assetPath.slice(assetPath.lastIndexOf("/") + 1);
+		const taken = collectTopLevelIdentifiers(ast);
+		identifier = safeAssetIdentifier(filename, taken);
+		const importStmt = `import ${identifier} from '${assetPath.replace(/'/g, "\\'")}';\n`;
+		const insertAt = imports.length > 0 ? imports[imports.length - 1].node.end : 0;
+		const prefix = imports.length > 0 ? "\n" : "";
+		importSplice = {
+			from: insertAt,
+			to: insertAt,
+			text: prefix + importStmt
+		};
+	}
+	const newAttr = `${attr}={${identifier}}`;
+	const existing = findJsxAttr(opening, attr);
+	let attrSplice;
+	if (existing) attrSplice = {
+		from: existing.start,
+		to: existing.end,
+		text: newAttr
+	};
+	else {
+		const name = opening.name;
+		attrSplice = {
+			from: name.end,
+			to: name.end,
+			text: ` ${newAttr}`
+		};
+	}
+	return {
+		importSplice,
+		attrSplice
+	};
+}
 function applyEdit(source, line, column, ops) {
 	if (ops.length === 0) return {
 		ok: true,
@@ -347,6 +457,36 @@ function applyEdit(source, line, column, ops) {
 		};
 		splices.push(result);
 	}
+	const assetOps = ops.flatMap((op) => op.kind === "set-attr-asset" ? [op] : []);
+	if (assetOps.length > 0) {
+		const ast = parseSource(source);
+		if (!ast) return {
+			ok: false,
+			status: 422,
+			error: "could not parse source"
+		};
+		const importSplices = [];
+		for (const op of assetOps) {
+			const plan = planAssetAttr(ast, element, op.attr, op.assetPath);
+			if ("error" in plan) return {
+				ok: false,
+				status: 422,
+				error: plan.error
+			};
+			splices.push(plan.attrSplice);
+			if (plan.importSplice) importSplices.push(plan.importSplice);
+		}
+		if (importSplices.length > 0) {
+			const from = importSplices[0].from;
+			const to = importSplices[0].to;
+			const text = importSplices.map((s) => s.text).join("");
+			splices.push({
+				from,
+				to,
+				text
+			});
+		}
+	}
 	if (splices.length === 0) return {
 		ok: true,
 		source
@@ -517,6 +657,45 @@ function commentsPlugin(opts) {
 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}$/;
+const ASSET_FORBIDDEN_RE = /[\x00-\x1F\x7F/\\:*?"<>|]/;
+const ASSET_MAX_BYTES = 25 * 1024 * 1024;
+const MIME_BY_EXT = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	svg: "image/svg+xml",
+	webp: "image/webp",
+	avif: "image/avif",
+	ico: "image/x-icon",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	json: "application/json",
+	txt: "text/plain; charset=utf-8",
+	md: "text/markdown; charset=utf-8"
+};
+function mimeForFilename(name) {
+	const dot = name.lastIndexOf(".");
+	if (dot < 0) return "application/octet-stream";
+	const ext = name.slice(dot + 1).toLowerCase();
+	return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+function validateAssetName(v) {
+	if (typeof v !== "string") return null;
+	const trimmed = v.trim();
+	if (trimmed.length < 1 || trimmed.length > 120) return null;
+	if (ASSET_FORBIDDEN_RE.test(trimmed)) return null;
+	if (trimmed.startsWith(".") || trimmed.startsWith("~")) return null;
+	if (trimmed === ".." || trimmed.split(/[/\\]/).includes("..")) return null;
+	const dot = trimmed.lastIndexOf(".");
+	if (dot <= 0 || dot === trimmed.length - 1) return null;
+	return trimmed;
+}
 async function readBody(req) {
 	return await new Promise((resolve, reject) => {
 		const chunks = [];
@@ -590,6 +769,22 @@ async function rmSlideDir(slidesRoot, slideId) {
 		return false;
 	}
 }
+function resolveAssetsDir(slidesRoot, slideId) {
+	if (!SLIDE_ID_RE.test(slideId)) return null;
+	const slideDir = path.resolve(slidesRoot, slideId);
+	if (!slideDir.startsWith(slidesRoot + path.sep)) return null;
+	const assetsDir = path.resolve(slideDir, "assets");
+	if (assetsDir !== path.join(slideDir, "assets")) return null;
+	return assetsDir;
+}
+function resolveAssetFile(slidesRoot, slideId, filename) {
+	const assetsDir = resolveAssetsDir(slidesRoot, slideId);
+	if (!assetsDir) return null;
+	if (!validateAssetName(filename)) return null;
+	const file = path.resolve(assetsDir, filename);
+	if (!file.startsWith(assetsDir + path.sep)) return null;
+	return file;
+}
 function resolveSlideEntry(slidesRoot, slideId) {
 	if (!SLIDE_ID_RE.test(slideId)) return null;
 	const dir = path.resolve(slidesRoot, slideId);
@@ -690,6 +885,22 @@ function filesPlugin(opts) {
 					event: "open-slide:files-changed"
 				});
 			});
+			const onAssetChange = (p) => {
+				if (!p.startsWith(slidesRoot + path.sep)) return;
+				const rel = p.slice(slidesRoot.length + 1);
+				const parts = rel.split(path.sep);
+				if (parts.length < 3 || parts[1] !== "assets") return;
+				const slideId = parts[0];
+				if (!SLIDE_ID_RE.test(slideId)) return;
+				server.ws.send({
+					type: "custom",
+					event: "open-slide:assets-changed",
+					data: { slideId }
+				});
+			};
+			server.watcher.on("add", onAssetChange);
+			server.watcher.on("change", onAssetChange);
+			server.watcher.on("unlink", onAssetChange);
 			server.middlewares.use("/__slides", async (req, res, next) => {
 				const url = new URL(req.url ?? "/", "http://local");
 				const method = req.method ?? "GET";
@@ -733,6 +944,172 @@ function filesPlugin(opts) {
 					json(res, 500, { error: String(err.message ?? err) });
 				}
 			});
+			server.middlewares.use("/__assets", async (req, res, next) => {
+				const url = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				try {
+					const listMatch = url.pathname.match(/^\/([^/]+)\/?$/);
+					const fileMatch = url.pathname.match(/^\/([^/]+)\/([^/]+)$/);
+					if (listMatch && method === "GET") {
+						const slideId = listMatch[1];
+						const assetsDir = resolveAssetsDir(slidesRoot, slideId);
+						if (!assetsDir) return json(res, 400, { error: "invalid slideId" });
+						let entries;
+						try {
+							entries = await fs.readdir(assetsDir);
+						} catch (err) {
+							if (err.code === "ENOENT") return json(res, 200, { assets: [] });
+							throw err;
+						}
+						const assets = [];
+						for (const name of entries) {
+							if (!validateAssetName(name)) continue;
+							const stat = await fs.stat(path.join(assetsDir, name));
+							if (!stat.isFile()) continue;
+							assets.push({
+								name,
+								size: stat.size,
+								mtime: stat.mtimeMs,
+								mime: mimeForFilename(name),
+								url: `/__assets/${slideId}/${encodeURIComponent(name)}`
+							});
+						}
+						assets.sort((a, b) => a.name.localeCompare(b.name));
+						return json(res, 200, { assets });
+					}
+					if (fileMatch) {
+						const slideId = fileMatch[1];
+						const filename = decodeURIComponent(fileMatch[2]);
+						const file = resolveAssetFile(slidesRoot, slideId, filename);
+						if (!file) return json(res, 400, { error: "invalid path" });
+						if (method === "GET") try {
+							const buf = await fs.readFile(file);
+							res.statusCode = 200;
+							res.setHeader("content-type", mimeForFilename(filename));
+							res.setHeader("cache-control", "no-store");
+							res.end(buf);
+							return;
+						} catch (err) {
+							if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+							throw err;
+						}
+						if (method === "POST") {
+							const overwrite = url.searchParams.get("overwrite") === "1";
+							const lenHeader = req.headers["content-length"];
+							const len = typeof lenHeader === "string" ? Number(lenHeader) : NaN;
+							if (Number.isFinite(len) && len > ASSET_MAX_BYTES) return json(res, 413, { error: "file too large" });
+							if (!overwrite) try {
+								await fs.access(file);
+								return json(res, 409, { error: "asset exists" });
+							} catch {}
+							const assetsDir = resolveAssetsDir(slidesRoot, slideId);
+							if (!assetsDir) return json(res, 400, { error: "invalid slideId" });
+							await fs.mkdir(assetsDir, { recursive: true });
+							const chunks = [];
+							let total = 0;
+							let oversized = false;
+							await new Promise((resolve, reject) => {
+								req.on("data", (c) => {
+									total += c.length;
+									if (total > ASSET_MAX_BYTES) {
+										oversized = true;
+										req.destroy();
+										return;
+									}
+									chunks.push(c);
+								});
+								req.on("end", () => resolve());
+								req.on("error", reject);
+							});
+							if (oversized) return json(res, 413, { error: "file too large" });
+							await fs.writeFile(file, Buffer.concat(chunks));
+							return json(res, 200, {
+								ok: true,
+								name: filename,
+								size: total,
+								mime: mimeForFilename(filename),
+								url: `/__assets/${slideId}/${encodeURIComponent(filename)}`
+							});
+						}
+						if (method === "PATCH") {
+							const body = await readBody(req);
+							const target = validateAssetName(body.name);
+							if (!target) return json(res, 400, { error: "invalid name" });
+							if (target === filename) return json(res, 200, {
+								ok: true,
+								name: filename
+							});
+							const dest = resolveAssetFile(slidesRoot, slideId, target);
+							if (!dest) return json(res, 400, { error: "invalid name" });
+							try {
+								await fs.access(dest);
+								return json(res, 409, { error: "target exists" });
+							} catch {}
+							try {
+								await fs.rename(file, dest);
+							} catch (err) {
+								if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+								throw err;
+							}
+							return json(res, 200, {
+								ok: true,
+								name: target
+							});
+						}
+						if (method === "DELETE") {
+							try {
+								await fs.unlink(file);
+							} catch (err) {
+								if (err.code === "ENOENT") return json(res, 404, { error: "asset not found" });
+								throw err;
+							}
+							return json(res, 200, { ok: true });
+						}
+					}
+					return next();
+				} catch (err) {
+					json(res, 500, { error: String(err.message ?? err) });
+				}
+			});
+			server.middlewares.use("/__svgl", async (req, res, next) => {
+				const reqUrl = new URL(req.url ?? "/", "http://local");
+				const method = req.method ?? "GET";
+				if (method !== "GET") return next();
+				try {
+					let target = null;
+					if (reqUrl.pathname === "/search") {
+						const params = new URLSearchParams();
+						const q = reqUrl.searchParams.get("q");
+						const limit = reqUrl.searchParams.get("limit");
+						if (q) params.set("search", q);
+						if (limit) params.set("limit", limit);
+						const qs = params.toString();
+						target = `https://api.svgl.app/${qs ? `?${qs}` : ""}`;
+					} else if (reqUrl.pathname === "/svg") {
+						const u = reqUrl.searchParams.get("u");
+						if (!u) return json(res, 400, { error: "missing u" });
+						let parsed;
+						try {
+							parsed = new URL(u);
+						} catch {
+							return json(res, 400, { error: "invalid u" });
+						}
+						if (parsed.protocol !== "https:") return json(res, 400, { error: "https only" });
+						const host = parsed.hostname.toLowerCase();
+						if (host !== "svgl.app" && !host.endsWith(".svgl.app")) return json(res, 400, { error: "host not allowed" });
+						target = parsed.toString();
+					} else return next();
+					const upstream = await fetch(target);
+					const ct = upstream.headers.get("content-type") ?? "application/octet-stream";
+					res.statusCode = upstream.status;
+					res.setHeader("content-type", ct);
+					res.setHeader("cache-control", "no-store");
+					const buf = Buffer.from(await upstream.arrayBuffer());
+					res.end(buf);
+				} catch (err) {
+					json(res, 502, { 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";

package/dist/{dev-CJX97uiy.js → dev-B3JzCYn7.js}

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

package/dist/{preview-IuLPcL5y.js → preview-UikovHEt.js}

@@ -1,4 +1,4 @@
-import { createViteConfig } from "./config-CtwxMYv9.js";
+import { createViteConfig } from "./config-LZM903FE.js";
 import { mergeConfig, preview as preview$1 } from "vite";
 
 //#region src/cli/preview.ts

package/dist/vite/index.js

@@ -1,3 +1,3 @@
-import { createViteConfig } from "../config-CtwxMYv9.js";
+import { createViteConfig } from "../config-LZM903FE.js";
 
 export { createViteConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-slide/core",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "Runtime and CLI for open-slide — write slides in slides/, we handle the rest.",
   "type": "module",
   "exports": {