imprensa 0.1.0

package/dist/prerender-core-D4Li--RS.mjs

@@ -0,0 +1,172 @@
+//#region src/core/prerender-head.ts
+function flattenTagProps(entry) {
+	const props = {};
+	for (const [key, val] of Object.entries(entry)) if (typeof val === "string") props[key] = val;
+	else if (typeof val === "number" || typeof val === "boolean") props[key] = String(val);
+	return props;
+}
+function isPlainTag(entry) {
+	return !("call" in entry);
+}
+function headMetaEntries(head) {
+	if (!Array.isArray(head.meta)) return [];
+	return head.meta.flatMap((entry) => typeof entry === "object" && entry !== null && isPlainTag(entry) ? [flattenTagProps(entry)] : []);
+}
+function headLinkEntries(head) {
+	if (!Array.isArray(head.link)) return [];
+	return head.link.flatMap((entry) => typeof entry === "object" && entry !== null && isPlainTag(entry) ? [flattenTagProps(entry)] : []);
+}
+function appendCanonicalTags(links, meta, canonicalUrl) {
+	return {
+		links: [...links.filter((link) => link.rel !== "canonical"), {
+			rel: "canonical",
+			href: canonicalUrl
+		}],
+		meta: [
+			...meta.filter((item) => item.property !== "og:url" && item.name !== "twitter:url"),
+			{
+				property: "og:url",
+				content: canonicalUrl
+			},
+			{
+				name: "twitter:url",
+				content: canonicalUrl
+			}
+		]
+	};
+}
+//#endregion
+//#region src/core/shiki-client-langs.ts
+function normalizeShikiLangId(lang) {
+	return lang === "ts" ? "typescript" : lang;
+}
+/** Grammars from `shiki.langs` (normalized), used for MDX build and browser alike. */
+function resolveShikiLangs(options) {
+	if (options === false) return ["typescript"];
+	return [...new Set(options?.langs ?? ["typescript"])].map(normalizeShikiLangId);
+}
+/** Theme ids from `shiki.themes` (values), used for MDX build and browser alike. */
+function resolveShikiThemeIds(options) {
+	if (options === false) return ["night-owl-light", "houston"];
+	const shiki = options ?? {};
+	if (!shiki.themes) return ["night-owl-light", "houston"];
+	return [...new Set(Object.values(shiki.themes))];
+}
+//#endregion
+//#region src/core/snippet-shiki.ts
+const WRAPPER_CLASS = "max-w-full overflow-x-auto rounded-xl border border-areia-border text-xs leading-relaxed [&_pre]:min-w-max [&_pre]:p-4 [&_pre]:text-xs [&_pre]:leading-relaxed [&_pre]:!m-0";
+function themePair(shiki) {
+	if (shiki === false || !shiki?.themes) return {
+		light: "night-owl-light",
+		dark: "houston"
+	};
+	return shiki.themes;
+}
+async function getHighlighter(shiki) {
+	const { createConfiguredHighlighterCore } = await import("./core/shiki-build.mjs");
+	return createConfiguredHighlighterCore(resolveShikiThemeIds(shiki), resolveShikiLangs(shiki));
+}
+async function codeToSnippetHtml(code, lang, shiki) {
+	const h = await getHighlighter(shiki);
+	const themes = themePair(shiki);
+	return `<div class="${WRAPPER_CLASS}" data-imprensa-snippet>${h.codeToHtml(code, {
+		lang,
+		themes
+	})}</div>`;
+}
+const SNIPPET_SLOT_RE = /(<div data-ilha-slot="[^"]*" data-ilha-props='[^']*'>)(<div class="[^"]*" data-imprensa-snippet>[\s\S]*?<\/div>)(<\/div>)/g;
+/** Paint Snippet islands in prerendered HTML (same Shiki themes as MDX). */
+async function paintSnippetSlotsInHtml(html, shiki) {
+	if (shiki === false) return html;
+	let out = html;
+	const matches = [...html.matchAll(SNIPPET_SLOT_RE)];
+	for (const match of matches) {
+		const propsMatch = match[1].match(/data-ilha-props='([^']*)'/);
+		if (!propsMatch) continue;
+		try {
+			const props = JSON.parse(propsMatch[1]);
+			if (typeof props.code !== "string" || typeof props.lang !== "string") continue;
+			const painted = await codeToSnippetHtml(props.code, props.lang, shiki);
+			out = out.replace(match[0], `${match[1]}${painted}${match[3]}`);
+		} catch {}
+	}
+	return out;
+}
+//#endregion
+//#region src/core/prerender-core.ts
+function encodeBase64(value) {
+	const bufferCtor = globalThis.Buffer;
+	if (bufferCtor) return bufferCtor.from(value, "utf8").toString("base64");
+	return btoa(unescape(encodeURIComponent(value)));
+}
+function createPrerender(options) {
+	return async function prerender(data) {
+		const url = data?.url ?? "/";
+		const mdxPage = await options.renderMdx?.(url);
+		options.setPrerenderedMdxHtml?.(mdxPage?.html);
+		let renderedHtml = await options.pageRouter.renderHydratable(url, options.registry, { snapshot: true });
+		if (options.shiki !== false) renderedHtml = await paintSnippetSlotsInHtml(renderedHtml, options.shiki);
+		const html = renderedHtml.replace(/<script/gi, "&lt;script").replace(/<\/script>/gi, "&lt;/script&gt;");
+		const canonicalUrl = options.hostname ? new URL(url, options.hostname).href : void 0;
+		const mergedHead = {
+			...options.headDefaults,
+			...await options.getMdxHead?.(url)
+		};
+		let linkTags = headLinkEntries(mergedHead);
+		let metaTags = headMetaEntries(mergedHead);
+		if (canonicalUrl) {
+			const canonical = appendCanonicalTags(linkTags, metaTags, canonicalUrl);
+			linkTags = canonical.links;
+			metaTags = canonical.meta;
+		}
+		const head = {};
+		if (mergedHead.title) head.title = String(mergedHead.title);
+		const elements = /* @__PURE__ */ new Set();
+		for (const m of metaTags) elements.add({
+			type: "meta",
+			props: m
+		});
+		for (const l of linkTags) elements.add({
+			type: "link",
+			props: l
+		});
+		if (mdxPage && options.hostname) {
+			const pageUrl = new URL(url, options.hostname).href;
+			const metaList = metaTags;
+			const title = typeof mergedHead.title === "string" && mergedHead.title || metaList.find((m) => m.property === "og:title")?.content || "Documentation";
+			const description = metaList.find((m) => m.name === "description")?.content;
+			const jsonLd = {
+				"@context": "https://schema.org",
+				"@type": "TechArticle",
+				headline: title,
+				url: pageUrl,
+				mainEntityOfPage: pageUrl,
+				...description ? { description } : {},
+				publisher: {
+					"@type": "Organization",
+					name: "Imprensa",
+					url: options.hostname
+				}
+			};
+			elements.add({
+				type: "script",
+				props: { type: "application/ld+json" },
+				children: JSON.stringify(jsonLd)
+			});
+		}
+		if (elements.size > 0) head.elements = elements;
+		const links = options.pageRouter.routes().map((route) => route.pattern).filter((link) => !link.includes("*"));
+		for (const routePath of options.mdxRoutes ?? []) links.push(routePath);
+		return {
+			html,
+			head: Object.keys(head).length > 0 ? head : void 0,
+			links: new Set(links),
+			data: mdxPage ? {
+				mdxHtmlBase64: encodeBase64(mdxPage.html),
+				mdxPath: mdxPage.path
+			} : void 0
+		};
+	};
+}
+//#endregion
+export { resolveShikiThemeIds as i, codeToSnippetHtml as n, resolveShikiLangs as r, createPrerender as t };

package/dist/prerender-core-DBi9ntWW.d.mts

@@ -0,0 +1,48 @@
+import { t as ImprensaShikiOptions } from "./shiki-gFey7C-z.mjs";
+import { HydrateOptions, RouterBuilder } from "@ilha/router";
+import { PrerenderArguments } from "vite-prerender-plugin";
+import { Island } from "ilha";
+import { ResolvableHead } from "unhead/types";
+
+//#region src/core/ilha-types.d.ts
+/** Island registry produced by `@ilha/router` codegen (`ilha:pages/*`). */
+type ImprensaIslandRegistry = Record<string, Island<Record<string, unknown>, Record<string, unknown>>>;
+/** Re-export router surface used by imprensa runtime and prerender (matches `RouterBuilder`). */
+type ImprensaPageRouter = RouterBuilder;
+//#endregion
+//#region src/core/prerender-core.d.ts
+/** Minimal router surface for apps that re-export codegen `pageRouter` into prerender. */
+type RouterLike = Pick<ImprensaPageRouter, "mount" | "hydrate" | "renderHydratable" | "routes">;
+type RenderedMdx = {
+  html: string;
+  path: string;
+} | undefined;
+type ImprensaPrerenderOptions = {
+  pageRouter: RouterLike;
+  registry: ImprensaIslandRegistry;
+  mdxRoutes?: Iterable<string>;
+  renderMdx?: (url: string) => RenderedMdx | Promise<RenderedMdx>;
+  setPrerenderedMdxHtml?: (html: string | undefined) => void;
+  getMdxHead?: (url: string) => ResolvableHead | undefined | Promise<ResolvableHead | undefined>;
+  headDefaults?: ResolvableHead | null;
+  hostname?: string;
+  shiki?: ImprensaShikiOptions;
+};
+declare function createPrerender(options: ImprensaPrerenderOptions): (data?: PrerenderArguments) => Promise<{
+  html: string;
+  head: {
+    title?: string;
+    elements?: Set<{
+      type: string;
+      props: Record<string, string>;
+      children?: string;
+    }>;
+  } | undefined;
+  links: Set<string>;
+  data: {
+    mdxHtmlBase64: string;
+    mdxPath: string;
+  } | undefined;
+}>;
+//#endregion
+export { ImprensaIslandRegistry as a, HydrateOptions as i, RouterLike as n, createPrerender as r, ImprensaPrerenderOptions as t };

package/dist/rehype-BWpGaBql.mjs

@@ -0,0 +1,182 @@
+import path from "node:path";
+import fs from "node:fs";
+//#region src/docs/rehype/types.ts
+function isLocalLink(value) {
+	return typeof value === "string" && value.startsWith("/") && !value.startsWith("//") && !value.startsWith("/__");
+}
+//#endregion
+//#region src/docs/rehype/route-graph.ts
+const routesFile = path.join(process.cwd(), ".ilha", "routes.ts");
+const pagesDir = path.join(process.cwd(), "src", "pages");
+let routeCache;
+function normalizeRoute(value) {
+	try {
+		return new URL(value, "http://localhost").pathname.replace(/\/+$/, "") || "/";
+	} catch {
+		return value.replace(/\/+$/, "") || "/";
+	}
+}
+function routePatternToRegex(pattern) {
+	if (pattern === "/") return /^\/$/;
+	const source = pattern.replace(/\/+$/, "").split("/").filter(Boolean).map((segment) => {
+		if (segment === "*") return "[^/]+";
+		if (segment.startsWith(":")) return "[^/]+";
+		return segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	}).join("/");
+	return new RegExp(`^/${source}$`);
+}
+function pageFileToRoute(filePath) {
+	const routePath = path.relative(pagesDir, filePath).replace(/\\/g, "/").replace(/\.(?:[cm]?[jt]sx?|mdx?)$/, "").replace(/\/index$/, "").split("/").filter((segment) => !segment.startsWith("+") && !/^\(.+\)$/.test(segment)).join("/");
+	if (!routePath || routePath === "index") return "/";
+	if (routePath.includes("[")) return void 0;
+	return normalizeRoute(`/${routePath}`);
+}
+function walk(dir, callback) {
+	if (!fs.existsSync(dir)) return;
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const entryPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) walk(entryPath, callback);
+		else callback(entryPath);
+	}
+}
+function getRoutes() {
+	if (routeCache) return routeCache;
+	const concrete = /* @__PURE__ */ new Set();
+	const patterns = [];
+	if (fs.existsSync(routesFile)) {
+		const source = fs.readFileSync(routesFile, "utf8");
+		for (const match of source.matchAll(/\.route\(\s*["'`]([^"'`]+)["'`]/g)) {
+			const routePath = normalizeRoute(match[1]);
+			if (routePath.includes("**")) continue;
+			if (/[*:]/.test(routePath)) patterns.push(routePatternToRegex(routePath));
+			else concrete.add(routePath);
+		}
+	}
+	walk(pagesDir, (filePath) => {
+		if (!/\.(?:[cm]?[jt]sx?|mdx?)$/.test(filePath)) return;
+		const routePath = pageFileToRoute(filePath);
+		if (routePath) concrete.add(routePath);
+	});
+	routeCache = {
+		concrete,
+		patterns
+	};
+	return routeCache;
+}
+function hasRoute(href) {
+	const routePath = normalizeRoute(href);
+	const { concrete, patterns } = getRoutes();
+	return concrete.has(routePath) || patterns.some((pattern) => pattern.test(routePath));
+}
+function walkPages(callback) {
+	walk(pagesDir, callback);
+}
+//#endregion
+//#region src/docs/rehype/heading-utils.ts
+let anchorCache;
+function textContent(node) {
+	if (!node) return "";
+	if (typeof node.value === "string") return node.value;
+	return (node.children ?? []).map(textContent).join("");
+}
+function slugifyHeading(value) {
+	return value.trim().toLowerCase().replace(/<[^>]+>/g, "").replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
+}
+function collectHeadings(node, headings = []) {
+	if (!node) return headings;
+	if (node.type === "element" && /^h[1-6]$/.test(node.tagName ?? "")) headings.push(node);
+	for (const child of node.children ?? []) if (child) collectHeadings(child, headings);
+	return headings;
+}
+function headingId(node) {
+	const id = node.properties?.id;
+	return typeof id === "string" ? id : slugifyHeading(textContent(node));
+}
+function markdownHeadingIds(source) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/^#{1,6}\s+(.+)$/gm)) ids.add(slugifyHeading(match[1].replace(/\s+#+\s*$/, "")));
+	return ids;
+}
+function getAnchorMap() {
+	if (anchorCache) return anchorCache;
+	const anchors = /* @__PURE__ */ new Map();
+	walkPages((filePath) => {
+		if (!/\.mdx?$/.test(filePath)) return;
+		const routePath = pageFileToRoute(filePath);
+		if (!routePath) return;
+		anchors.set(routePath, markdownHeadingIds(fs.readFileSync(filePath, "utf8")));
+	});
+	anchorCache = anchors;
+	return anchorCache;
+}
+function fail(file, node, rule, reason) {
+	const place = node?.position?.start ? {
+		line: node.position.start.line,
+		column: node.position.start.column
+	} : void 0;
+	const filePath = file.path ? path.relative(process.cwd(), file.path) : "unknown file";
+	const suffix = place?.line ? `:${place.line}:${place.column ?? 1}` : "";
+	throw new Error(`${filePath}${suffix} error ${rule} ${reason}`);
+}
+function visitLinks(node, callback) {
+	if (!node) return;
+	if (node.type === "element" && node.tagName === "a" && isLocalLink(node.properties?.href)) callback(node, node.properties.href);
+	for (const child of node.children ?? []) if (child) visitLinks(child, callback);
+}
+//#endregion
+//#region src/docs/rehype/preview.ts
+function rehypePreview() {
+	function visit(node) {
+		if (!node.children) return;
+		for (let i = 0; i < node.children.length; i++) {
+			const child = node.children[i];
+			if (child.type === "element" && child.tagName === "pre" && child.children?.[0]?.tagName === "code") {
+				const code = child.children[0];
+				if (!(code.properties?.metastring ?? code.properties?.meta ?? "").includes("preview")) {
+					visit(child);
+					continue;
+				}
+				const text = textContent(code);
+				node.children[i] = {
+					type: "element",
+					tagName: "Preview",
+					properties: { code: text },
+					children: []
+				};
+			} else visit(child);
+		}
+	}
+	return (tree) => visit(tree);
+}
+//#endregion
+//#region src/docs/rehype/dead-links.ts
+function rehypeDeadLinks() {
+	return (tree, file) => {
+		const headings = collectHeadings(tree);
+		const h1s = headings.filter((heading) => heading.tagName === "h1");
+		if (h1s.length !== 1) fail(file, h1s[1] ?? headings[0], "rehype-heading-structure", `Expected exactly one h1, found ${h1s.length}.`);
+		for (let index = 1; index < headings.length; index++) {
+			const previousLevel = Number(headings[index - 1].tagName?.slice(1));
+			const currentLevel = Number(headings[index].tagName?.slice(1));
+			if (currentLevel > previousLevel + 1) fail(file, headings[index], "rehype-heading-structure", `Skipped heading level from h${previousLevel} to h${currentLevel}.`);
+		}
+		const ids = /* @__PURE__ */ new Set();
+		for (const heading of headings) {
+			const id = headingId(heading);
+			if (ids.has(id)) fail(file, heading, "rehype-duplicate-heading-id", `Duplicate heading id "${id}".`);
+			ids.add(id);
+		}
+		const currentRoute = file.path ? pageFileToRoute(file.path) : void 0;
+		visitLinks(tree, (node, href) => {
+			const [rawPath, rawHash] = href.split("#");
+			const routePath = normalizeRoute(rawPath || currentRoute || "/");
+			if (!hasRoute(routePath)) fail(file, node, "rehype-dead-links", `Dead link "${href}". No matching route was found in .ilha/routes.ts or src/pages.`);
+			if (rawHash) {
+				const anchor = decodeURIComponent(rawHash);
+				if (!(routePath === currentRoute ? ids : getAnchorMap().get(routePath))?.has(anchor)) fail(file, node, "rehype-dead-anchor-links", `Dead anchor link "${href}". No heading id "${anchor}" exists on "${routePath}".`);
+			}
+		});
+	};
+}
+//#endregion
+export { rehypePreview as n, rehypeDeadLinks as t };

package/dist/search-store-DDGHRAKl.mjs

@@ -0,0 +1,64 @@
+import MiniSearch from "minisearch";
+import { searchDocuments } from "imprensa/mdx";
+import { createStore } from "@ilha/store";
+//#region src/components/search-core.tsx
+const searchIndex = new MiniSearch({
+	fields: ["title", "text"],
+	storeFields: [
+		"title",
+		"path",
+		"text"
+	],
+	searchOptions: {
+		boost: { title: 3 },
+		fuzzy: .2,
+		prefix: true
+	}
+});
+searchIndex.addAll(searchDocuments);
+function getQueryTerms(query) {
+	return query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+}
+function getTextMatchIndex(text, query) {
+	const normalizedText = text.toLowerCase();
+	return getQueryTerms(query).map((term) => normalizedText.indexOf(term)).filter((index) => index >= 0).sort((a, b) => a - b)[0];
+}
+function getMatchedExcerpt(text, query) {
+	const firstMatch = getTextMatchIndex(text, query);
+	if (firstMatch === void 0) return void 0;
+	const start = Math.max(0, firstMatch - 60);
+	const end = Math.min(text.length, firstMatch + 140);
+	const excerpt = text.slice(start, end).trim();
+	return `${start > 0 ? "…" : ""}${excerpt}${end < text.length ? "…" : ""}`;
+}
+function getSearchResults(query) {
+	const trimmedQuery = query.trim();
+	if (!trimmedQuery) return [];
+	return searchIndex.search(trimmedQuery).slice(0, 8).map((result) => ({
+		id: result.id,
+		title: result.title,
+		path: result.path,
+		text: result.text
+	}));
+}
+//#endregion
+//#region src/components/search-store.ts
+const searchStore = createStore({
+	open: false,
+	query: ""
+});
+/** Hoisted for `bind:open` / portaled bridge — same alien-signals graph as islands. */
+const searchOpen = searchStore.bind((s) => s.open);
+const searchQuery = searchStore.bind((s) => s.query);
+function closeSearch() {
+	searchOpen(false);
+}
+function openSearch() {
+	searchOpen(true);
+}
+function toggleSearch() {
+	if (searchOpen()) closeSearch();
+	else openSearch();
+}
+//#endregion
+export { toggleSearch as a, searchQuery as i, openSearch as n, getMatchedExcerpt as o, searchOpen as r, getSearchResults as s, closeSearch as t };