@twango/twiki 0.0.0-stage → 0.1.1

package/site/src/lib/rmd.ts

@@ -0,0 +1,156 @@
+import wikiLink from '@flowershow/remark-wiki-link';
+import { slug } from 'github-slugger';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkGfm from 'remark-gfm';
+import remarkMath from 'remark-math';
+import remarkRehype from 'remark-rehype';
+import rehypeKatex from 'rehype-katex';
+import { toHtml } from 'hast-util-to-html';
+import { SKIP, visit } from 'unist-util-visit';
+import { parse } from 'yaml';
+import type { Root as HtmlRoot } from 'hast';
+import type { Root, RootContent } from 'mdast';
+import { fileRoute, type CourseFile } from './files';
+
+export type RmdBlock =
+	| { kind: 'markdown'; html: string }
+	| {
+			kind: 'r';
+			code: string;
+			label: string;
+			evaluate: boolean;
+			show: boolean;
+	  };
+
+export function relativeFile(path: string, target: string) {
+	const parts = path.split('/').slice(0, -1);
+	for (const part of target.split('/')) {
+		if (part === '..') {
+			if (!parts.length) return;
+			parts.pop();
+		} else if (part && part !== '.') parts.push(part);
+	}
+	return parts.join('/');
+}
+
+// Raw HTML is omitted, and URL schemes are restricted before producing HTML.
+export async function parseRmd(source: string, course: string, path: string, files: CourseFile[]) {
+	let title = path.split('/').at(-1) ?? 'R Markdown';
+	const frontmatter = source.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+	if (frontmatter) {
+		const metadata = parse(frontmatter[1]);
+		if (typeof metadata?.title === 'string') title = metadata.title;
+		source = source.slice(frontmatter[0].length);
+	}
+	const parser = unified()
+		.use(remarkParse)
+		.use(remarkGfm)
+		.use(remarkMath)
+		.use(wikiLink, {
+			urlResolver: ({ filePath: target, heading, isEmbed }) => {
+				// Flowershow 3.x retains the backslash before table alias separators.
+				target = target.replace(/\\$/, '').trim();
+				heading = heading.replace(/\\$/, '').trim();
+				if (/^(?:[a-z][a-z\d+.-]*:|\/)/i.test(target)) return '';
+				if (!target) return heading ? `#${slug(heading)}` : '';
+				const qualified = target.startsWith(`${course}/`);
+				const local = qualified ? target.slice(course.length + 1) : target;
+				const relative = qualified ? local : relativeFile(path, local);
+				const candidates = files.filter((file) =>
+					[file.path, file.path.replace(/\.md$/i, '')].some(
+						(name) =>
+							name === local ||
+							name === relative ||
+							(!local.includes('/') && name.split('/').at(-1) === local)
+					)
+				);
+				const file =
+					candidates.find((file) => file.path === local || file.path === relative) ??
+					(candidates.length === 1 ? candidates[0] : undefined);
+				if (isEmbed && file?.kind === 'image' && !file.locked && file.download)
+					return file.download;
+				const destination = file
+					? file.note
+						? `/${file.note.replace(/^[/\\\u0000-\u0020\u007f]+/, '')}`
+						: fileRoute(course, file.path)
+					: `/${course}/${(qualified ? local : (relative ?? local)).replace(/\.md$/i, '')}`;
+				return destination + (heading ? `#${slug(heading)}` : '');
+			}
+		});
+	const renderer = unified().use(remarkRehype).use(rehypeKatex);
+	const tree = parser.parse(source);
+	// Keep our authorization and safe-HTML policy around the library's parsed nodes.
+	visit(tree, (node, index, parent) => {
+		if (!parent || index === undefined || !['wikiLink', 'embed'].includes(node.type)) return;
+		const wiki = node as unknown as {
+			type: string;
+			value: string;
+			data: { path: string; alias?: string };
+		};
+		const url = wiki.data.path;
+		parent.children[index] =
+			wiki.type === 'embed' &&
+			files.some((file) => file.kind === 'image' && !file.locked && file.download === url)
+				? { type: 'image', url, alt: wiki.data.alias ?? wiki.value }
+				: { type: 'link', url, children: [{ type: 'text', value: wiki.data.alias ?? wiki.value }] };
+	});
+
+	// PDF layout directives have no notebook equivalent. Match whole prose
+	// paragraphs so inline explanations, code examples, and R chunks survive.
+	visit(tree, 'paragraph', (node, index, parent) => {
+		const child = node.children[0];
+		if (
+			parent &&
+			index !== undefined &&
+			node.children.length === 1 &&
+			child.type === 'text' &&
+			/^\s*\\(?:vspace\*?\{[^{}\n]+\}|newpage|pagebreak(?:\[[0-4]\])?)\s*$/.test(child.value)
+		) {
+			parent.children.splice(index, 1);
+			return [SKIP, index];
+		}
+	});
+	visit(tree, (node) => {
+		if (node.type !== 'image' && node.type !== 'link' && node.type !== 'definition') return;
+		const normalized = node.url.replace(/[\u0000-\u0020\u007f]/g, '');
+		if (/^[a-z][a-z\d+.-]*:/i.test(normalized) && !/^(https?:|mailto:)/i.test(normalized)) {
+			node.url = '';
+			return;
+		}
+		if (/^(?:[a-z][a-z\d+.-]*:|\/|#)/i.test(normalized)) return;
+		const resolved = relativeFile(path, node.url);
+		const file = files.find((file) => file.path === resolved);
+		if (file)
+			node.url =
+				node.type === 'image' && !file.locked && file.download
+					? file.download
+					: fileRoute(course, file.path);
+	});
+	const blocks: RmdBlock[] = [];
+	let prose: RootContent[] = [];
+	async function flush() {
+		if (!prose.length) return;
+		const tree: Root = { type: 'root', children: prose };
+		blocks.push({ kind: 'markdown', html: toHtml((await renderer.run(tree)) as HtmlRoot) });
+		prose = [];
+	}
+	for (const node of tree.children) {
+		const header = node.type === 'code' ? `${node.lang ?? ''} ${node.meta ?? ''}`.trim() : '';
+		if (node.type === 'code' && /^\{r(?:[\s,}]|$)/i.test(header)) {
+			await flush();
+			const options = header.slice(2).replace(/}\s*$/, '');
+			blocks.push({
+				kind: 'r',
+				code: node.value,
+				label:
+					options.split(',')[0].trim() ||
+					`Chunk ${blocks.filter((b) => b.kind === 'r').length + 1}`,
+				evaluate: !/\beval\s*=\s*(FALSE|F)\b/i.test(options),
+				show: !/\b(include|echo)\s*=\s*(FALSE|F)\b/i.test(options)
+			});
+		} else prose.push(node);
+	}
+	await flush();
+	return { title, blocks };
+}

package/site/src/lib/server/access-admin.ts

@@ -0,0 +1,33 @@
+import { error, type RequestEvent } from '@sveltejs/kit';
+import { createAuth, type AuthEnv } from '../../../worker/auth';
+import { isOwner } from '../../../worker/access';
+import { and, eq, inArray } from 'drizzle-orm';
+import { database } from '../../../database';
+import { account, session, siteAccess } from '../../../database/schema';
+
+export async function requireOwner(event: RequestEvent) {
+	const env = event.platform?.env;
+	if (!env) error(503, 'Authentication unavailable');
+	const session = await createAuth(env).api.getSession({ headers: event.request.headers });
+	if (!session || !(await isOwner(env.DB, session.user.id, env.OWNER_GITHUB_ID))) {
+		error(403, 'Only the site owner can manage access.');
+	}
+	return env;
+}
+
+export async function revokeAccess(env: AuthEnv, githubId: string) {
+	if (githubId === env.OWNER_GITHUB_ID) error(400, 'Owner access cannot be revoked.');
+	const db = database(env.DB);
+	await db.batch([
+		db.delete(siteAccess).where(eq(siteAccess.githubId, githubId)),
+		db.delete(session).where(
+			inArray(
+				session.userId,
+				db
+					.select({ userId: account.userId })
+					.from(account)
+					.where(and(eq(account.providerId, 'github'), eq(account.accountId, githubId)))
+			)
+		)
+	]);
+}

package/site/src/lib/server/content-model.ts

@@ -0,0 +1,253 @@
+import type {
+	ContentManifest,
+	FolderEntry,
+	FolderListing,
+	ManifestPage,
+	NavNode,
+	TreeNode
+} from '../types';
+import { site } from '../config';
+
+export function createContentModel(manifest: ContentManifest) {
+	const getManifest = () => manifest;
+	/**
+	 * Canonical slug → display route (no leading/trailing slash; `''` = home).
+	 * Trailing `index` segments are trimmed from URLs.
+	 */
+	function displayRoute(slug: string): string {
+		if (slug === 'index') return '';
+		if (slug.endsWith('/index')) return slug.slice(0, -'/index'.length);
+		return slug;
+	}
+
+	/** Display route → canonical page slug, or undefined if no page lives there. */
+	function pageSlugForRoute(route: string): string | undefined {
+		const { pages } = getManifest();
+		if (route === '') return Object.hasOwn(pages, 'index') ? 'index' : undefined;
+		if (Object.hasOwn(pages, route) && !route.endsWith('/index')) return route;
+		if (Object.hasOwn(pages, `${route}/index`)) return `${route}/index`;
+		// A literal `…/index` URL is not canonical (the live site never emits it).
+		return undefined;
+	}
+
+	/** Folders that have no index page and therefore get a generated listing. */
+	function listingFolders(): string[] {
+		const m = getManifest();
+		return m.folders.filter(
+			(f) => !Object.hasOwn(m.pages, `${f}/index`) && !Object.hasOwn(m.pages, f)
+		);
+	}
+
+	/**
+	 * Every route served by the catch-all `[...slug]` page route:
+	 * all page display routes (including `''` = home) + generated folder listings.
+	 * Tag routes live under `src/routes/tags/` and are not included here.
+	 */
+	function contentEntries(): string[] {
+		const m = getManifest();
+		const routes = Object.keys(m.pages).map(displayRoute);
+		return [...new Set(['', ...routes, ...listingFolders()])];
+	}
+
+	/** Natural sort, Quartz Explorer-style (numeric, case-insensitive). */
+	const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+
+	function findTreeNode(folder: string): TreeNode | undefined {
+		let node: TreeNode | undefined = getManifest().tree;
+		if (folder === '') return node;
+		for (const segment of folder.split('/')) {
+			node = node?.children.find((c) => c.name === segment);
+			if (!node) return undefined;
+		}
+		return node;
+	}
+
+	function toNavNode(node: TreeNode): NavNode {
+		const indexSlug = `${node.slug}/index`;
+		const folders = node.children.map(toNavNode).sort((a, b) => collator.compare(a.title, b.title));
+		const pages = node.pages
+			.filter((p) => p.slug !== indexSlug)
+			.map(
+				(p): NavNode => ({
+					locked: getManifest().pages[p.slug]?.locked,
+					title: p.title,
+					route: `/${displayRoute(p.slug)}`,
+					children: [],
+					segment: p.slug.split('/').pop() ?? p.slug
+				})
+			)
+			.sort((a, b) => collator.compare(a.title, b.title));
+		return {
+			locked: getManifest().pages[indexSlug]?.locked,
+			// Explorer shows folder names (matching the live Quartz explorer), not
+			// index-page titles — those can be long ("Midterm 1 - Practice Questions").
+			title: node.name,
+			route: `/${node.slug}`, // every folder has a route: index page or listing
+			children: [...folders, ...pages],
+			segment: node.name
+		};
+	}
+
+	let navCache: NavNode[] | undefined;
+
+	/** Sidebar Explorer tree: course folders first, then root pages (minus home). */
+	function navTree(): NavNode[] {
+		if (navCache) return navCache;
+		const root = getManifest().tree;
+		const folders = root.children.map(toNavNode).sort((a, b) => collator.compare(a.title, b.title));
+		const rootPages = root.pages
+			.filter((p) => p.slug !== 'index')
+			.map(
+				(p): NavNode => ({
+					title: p.title,
+					route: `/${displayRoute(p.slug)}`,
+					children: [],
+					segment: p.slug
+				})
+			)
+			.sort((a, b) => collator.compare(a.title, b.title));
+		navCache = [...folders, ...rootPages];
+		return navCache;
+	}
+
+	function countPages(node: TreeNode): number {
+		return node.pages.length + node.children.reduce((n, c) => n + countPages(c), 0);
+	}
+
+	/** Listing data for a folder without its own index page. */
+	function folderListing(folder: string): FolderListing | undefined {
+		const m = getManifest();
+		if (folder !== '' && !m.folders.includes(folder)) return undefined;
+		const node = findTreeNode(folder);
+		if (!node) return undefined;
+		const subfolders: FolderEntry[] = node.children
+			.map((c) => ({ title: c.name, route: `/${c.slug}`, isFolder: true }))
+			.sort((a, b) => collator.compare(a.title, b.title));
+		const pages: FolderEntry[] = node.pages
+			.filter((p) => p.slug !== `${folder}/index`)
+			.map((p) => ({
+				title: p.title,
+				route: `/${displayRoute(p.slug)}`,
+				isFolder: false,
+				modified: m.pages[p.slug]?.dates.modified
+			}))
+			// Quartz folder pages list by date (newest first), then alphabetical.
+			.sort(
+				(a, b) =>
+					Date.parse(b.modified ?? '0') - Date.parse(a.modified ?? '0') ||
+					collator.compare(a.title, b.title)
+			);
+		return {
+			folder,
+			name: folder === '' ? site.name : (folder.split('/').pop() ?? folder),
+			entries: [
+				...subfolders,
+				...pages,
+				...(m.fileCourses?.includes(folder)
+					? [{ title: 'Files', route: `/${folder}/files`, isFolder: true }]
+					: [])
+			],
+			pageCount: countPages(node)
+		};
+	}
+
+	/** All tags (case-sensitive) with page counts, alphabetical. */
+	function tagIndex(): { tag: string; count: number }[] {
+		const { tags } = getManifest();
+		return Object.keys(tags)
+			.sort((a, b) => collator.compare(a, b))
+			.map((tag) => ({ tag, count: tags[tag].length }));
+	}
+
+	/** Pages for one tag (case-sensitive), newest first. */
+	function tagPages(tag: string): ManifestPage[] | undefined {
+		const m = getManifest();
+		const slugs = m.tags[tag];
+		if (!slugs) return undefined;
+		return slugs
+			.map((s) => m.pages[s])
+			.filter((p): p is ManifestPage => !!p)
+			.sort(
+				(a, b) =>
+					Date.parse(b.dates.modified) - Date.parse(a.dates.modified) ||
+					collator.compare(a.title, b.title)
+			);
+	}
+
+	function escapeXml(s: string): string {
+		return s
+			.replaceAll('&', '&')
+			.replaceAll('<', '&lt;')
+			.replaceAll('>', '&gt;')
+			.replaceAll('"', '&quot;');
+	}
+
+	function absoluteUrl(route: string): string {
+		return route === '' ? `${site.url}/` : `${site.url}/${route}`;
+	}
+
+	/** RSS feed matching the live `/index.xml` shape: latest 10 by modified date. */
+	function rssXml(): string {
+		const m = getManifest();
+		const items = Object.values(m.pages)
+			.filter((page) => !page.locked)
+			.sort((a, b) => Date.parse(b.dates.modified) - Date.parse(a.dates.modified))
+			.slice(0, 10)
+			.map((p) => {
+				const url = absoluteUrl(displayRoute(p.slug));
+				const description = p.description.replaceAll(']]>', ']]&gt;');
+				return `<item>
+    <title>${escapeXml(p.title)}</title>
+    <link>${url}</link>
+    <guid>${url}</guid>
+    <description><![CDATA[ ${description} ]]></description>
+    ${p.dates.published || p.dates.modified ? `<pubDate>${new Date(p.dates.published || p.dates.modified).toUTCString()}</pubDate>` : ''}
+  </item>`;
+			})
+			.join('');
+		return `<?xml version="1.0" encoding="UTF-8" ?>
+<rss version="2.0">
+    <channel>
+      <title>${escapeXml(site.title)}</title>
+      <link>${site.url}</link>
+      <description>Last 10 notes on ${escapeXml(site.title)}</description>
+      <generator>${site.url}</generator>
+      ${items}
+    </channel>
+  </rss>`;
+	}
+
+	/** Sitemap matching the live `/sitemap.xml` shape: every page, ISO lastmod. */
+	function sitemapXml(): string {
+		const m = getManifest();
+		const urls = Object.values(m.pages)
+			.filter((page) => !page.locked)
+			.map(
+				(p) => `<url>
+    <loc>${escapeXml(absoluteUrl(displayRoute(p.slug)))}</loc>
+    ${p.dates.modified ? `<lastmod>${p.dates.modified}</lastmod>` : ''}
+  </url>`
+			)
+			.join('');
+		const folders = m.fileCourses
+			? contentEntries()
+					.filter((route) => !pageSlugForRoute(route))
+					.map((route) => `<url><loc>${escapeXml(absoluteUrl(route))}</loc></url>`)
+					.join('')
+			: '';
+		return `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">${urls}${folders}</urlset>`;
+	}
+
+	return {
+		displayRoute,
+		pageSlugForRoute,
+		listingFolders,
+		contentEntries,
+		navTree,
+		folderListing,
+		tagIndex,
+		tagPages,
+		rssXml,
+		sitemapXml
+	};
+}