imprensa 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -462,13 +462,16 @@ export {
 `;
 //#endregion
 //#region src/docs/plugin/create-plugins.ts
-/** Resolved from published `dist/index.mjs` → `src/...`. */
+/**
+* MDX runtime config is transformed by this Vite plugin, so it needs the packaged source.
+* UI subpaths can use published dist files; consumers should not need the full source tree.
+*/
 const MDX_SOURCE = fileURLToPath(new URL("../src/docs/mdx.ts", import.meta.url));
 const MDX_RUNTIME_CONFIG = fileURLToPath(new URL("../src/docs/mdx/runtime-config.ts", import.meta.url));
-const COMPONENTS_INDEX = fileURLToPath(new URL("../src/components/index.tsx", import.meta.url));
-const DOC_ENTRY = fileURLToPath(new URL("../src/components/doc.tsx", import.meta.url));
-const CONFIG_STUB = fileURLToPath(new URL("../src/docs/config.ts", import.meta.url));
-const ICONS_ENTRY = fileURLToPath(new URL("../src/components/icons.tsx", import.meta.url));
+const COMPONENTS_INDEX = fileURLToPath(new URL("./components/index.mjs", import.meta.url));
+const DOC_ENTRY = fileURLToPath(new URL("./components/doc.mjs", import.meta.url));
+const CONFIG_STUB = fileURLToPath(new URL("./docs/config.mjs", import.meta.url));
+const ICONS_ENTRY = fileURLToPath(new URL("./components/icons.mjs", import.meta.url));
 const IMPRENSA_PRERENDER_ENTRY = path.resolve(fileURLToPath(new URL("./core/prerender-core.mjs", import.meta.url)));
 const IMPRENSA_CLIENT_RUNTIME = path.resolve(fileURLToPath(new URL("./core/client-runtime.mjs", import.meta.url)));
 function isMdxConfigTarget(id) {
@@ -598,8 +601,8 @@ export const shikiThemes = ${JSON.stringify(shikiThemes)};`;
 export const imprensaRepo = ${JSON.stringify(repo)};
 export const imprensaRepoBranch = ${JSON.stringify(repoBranch)};
 export const imprensaRepoPath = ${JSON.stringify(repoPath)};
-export const mdxRawSources = ${JSON.stringify(collectRawMdxSources(process.cwd(), contentDir))} as Record<string, string>;
-export const headDefaults = ${JSON.stringify(headDefaults ?? null)} as import("unhead/types").ResolvableHead | null;`);
+export const mdxRawSources = ${JSON.stringify(collectRawMdxSources(process.cwd(), contentDir))};
+export const headDefaults = ${JSON.stringify(headDefaults ?? null)};`);
 		},
 		handleHotUpdate(ctx) {
 			if (!isAppPageFile(ctx.file, ctx.server.config.root)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imprensa",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Vite plugin and runtime for Ilha + Areia documentation sites (MDX, prerender, search)",
   "keywords": [
     "areia",
@@ -28,6 +28,9 @@
   },
   "files": [
     "dist",
+    "src/docs/frontmatter.ts",
+    "src/docs/mdx.ts",
+    "src/docs/mdx/",
     "default.css",
     "index.d.ts",
     "README.md",

package/src/docs/frontmatter.ts

@@ -0,0 +1,31 @@
+/** Parsed YAML scalar from minimal frontmatter parser. */
+export type FrontmatterScalar = string | number | boolean | string[];
+
+export function parseScalar(value: string): FrontmatterScalar {
+  const trimmed = value.trim();
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed
+      .slice(1, -1)
+      .split(",")
+      .map((item) => item.trim().replace(/^['"]|['"]$/g, ""))
+      .filter(Boolean);
+  }
+  return trimmed.replace(/^['"]|['"]$/g, "");
+}
+
+export function toStringArray(
+  value: FrontmatterScalar | FrontmatterScalar[] | undefined,
+): string[] {
+  if (Array.isArray(value)) {
+    return value.flatMap((item) => (typeof item === "string" ? [item] : []));
+  }
+  if (typeof value === "string")
+    return value
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean);
+  return [];
+}

package/src/docs/mdx/document-text.ts

@@ -0,0 +1,96 @@
+import { parseScalar, toStringArray, type FrontmatterScalar } from "../frontmatter";
+import type { ContentMeta } from "./types";
+
+export function titleize(value: string) {
+  return value.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+
+export function stripFrontmatter(source: string) {
+  if (!source.startsWith("---")) return source;
+  const end = source.indexOf("\n---", 3);
+  return end === -1 ? source : source.slice(end + 4).replace(/^\s+/, "");
+}
+
+function titleFromDocument(filePath: string, rawSource: string) {
+  const documentSource = stripFrontmatter(rawSource);
+  const heading = documentSource.match(/^#\s+(.+)$/m);
+  const title = heading?.[1]?.trim();
+  if (title) return title;
+
+  const name = filePath
+    .replace(/\.mdx?$/, "")
+    .split("/")
+    .filter(Boolean)
+    .at(-1);
+
+  return titleize(name === "index" ? "overview" : (name ?? "Untitled"));
+}
+
+export function textFromRawDocument(source: string) {
+  return stripFrontmatter(source)
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`([^`]+)`/g, "$1")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/!\[[^\]]*\]\([^)]*\)/g, " ")
+    .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/[>*_~#-]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function parseFrontmatter(source: string): Record<string, FrontmatterScalar | FrontmatterScalar[]> {
+  if (!source.startsWith("---")) return {};
+  const end = source.indexOf("\n---", 3);
+  if (end === -1) return {};
+  const yaml = source.slice(4, end);
+  const entries: Record<string, FrontmatterScalar | FrontmatterScalar[]> = {};
+  let listKey: string | undefined;
+
+  for (const line of yaml.split("\n")) {
+    const listItem = line.match(/^\s*-\s*(.+)$/);
+    if (listItem && listKey) {
+      const existing = entries[listKey];
+      const list: FrontmatterScalar[] = Array.isArray(existing) ? [...existing] : [];
+      list.push(parseScalar(listItem[1]));
+      entries[listKey] = list;
+      continue;
+    }
+
+    const m = line.match(/^([\w-]+):\s*(.*)$/);
+    if (!m) continue;
+    listKey = undefined;
+    if (!m[2].trim()) {
+      entries[m[1]] = [];
+      listKey = m[1];
+    } else {
+      entries[m[1]] = parseScalar(m[2]);
+    }
+  }
+
+  return entries;
+}
+
+export function metaFromDocument(filePath: string, rawSource: string): ContentMeta {
+  const fm = parseFrontmatter(rawSource);
+  const title = typeof fm.title === "string" ? fm.title : titleFromDocument(filePath, rawSource);
+  const order = typeof fm.order === "number" ? fm.order : undefined;
+  const priority = typeof fm.priority === "number" ? fm.priority : order !== undefined ? -order : 0;
+
+  const type = fm.type === "custom" || fm.type === "link" ? fm.type : "doc";
+
+  return {
+    title,
+    description: typeof fm.description === "string" ? fm.description : undefined,
+    order,
+    priority,
+    type,
+    link: typeof fm.link === "string" ? fm.link : undefined,
+    external: fm.external === true,
+    section: typeof fm.section === "string" ? fm.section : undefined,
+    badge: typeof fm.badge === "string" ? fm.badge : undefined,
+    draft: fm.draft === true,
+    hidden: fm.hidden === true || fm.sidebar === false,
+    tags: toStringArray(fm.tags),
+  };
+}

package/src/docs/mdx/index.ts

@@ -0,0 +1,26 @@
+export { headDefaults } from "./runtime-config";
+
+export type {
+  ContentMeta,
+  ContentPageType,
+  ContentTreeNode,
+  MdxContent,
+  MdxModule,
+  SearchDocument,
+} from "./types";
+export { articleClass } from "./types";
+
+export { contentMeta, contentTree, mdxRoutes, searchDocuments } from "./routes";
+
+export {
+  getClientPrerenderedMdxHtml,
+  getMdxContent,
+  getMdxHead,
+  getPrerenderedMdxHtml,
+  loadMdxHtml,
+  renderMdx,
+  renderMdxContent,
+  setPrerenderedMdxHtml,
+} from "./render";
+
+export { getDocLinks, getMdxSourceForRoute } from "./source-links";

package/src/docs/mdx/render.ts

@@ -0,0 +1,91 @@
+import { raw } from "ilha";
+import type { ResolvableHead as Head } from "unhead/types";
+import type { MdxContent } from "./types";
+import { mdxPages } from "./routes";
+
+let prerenderedMdxHtml: string | undefined;
+
+function toHtml(content: MdxContent) {
+  return typeof content === "string" ? content : content.value;
+}
+
+function decodeBase64(value: string) {
+  const binary = atob(value);
+  const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+  return new TextDecoder().decode(bytes);
+}
+
+type PrerenderDataPayload = {
+  mdxHtml?: string;
+  mdxHtmlBase64?: string;
+  mdxPath?: string;
+};
+
+export function setPrerenderedMdxHtml(html: string | undefined) {
+  prerenderedMdxHtml = html;
+}
+
+export function getPrerenderedMdxHtml() {
+  return prerenderedMdxHtml;
+}
+
+export function getClientPrerenderedMdxHtml(path: string) {
+  if (typeof document === "undefined") return undefined;
+
+  const data = document.getElementById("prerender-data")?.textContent;
+  if (!data) return undefined;
+
+  try {
+    const parsed = JSON.parse(data) as PrerenderDataPayload;
+    const normalizedPath = path.replace(/\/$/, "") || "/";
+    if (parsed.mdxPath !== normalizedPath) return undefined;
+    if (typeof parsed.mdxHtmlBase64 === "string") return decodeBase64(parsed.mdxHtmlBase64);
+    return typeof parsed.mdxHtml === "string" ? parsed.mdxHtml : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function normalizePath(url: string) {
+  return new URL(url, "http://localhost").pathname.replace(/\/$/, "") || "/";
+}
+
+async function loadMdxModule(url: string) {
+  const pathname = normalizePath(url);
+  const loader = mdxPages.get(pathname);
+  return loader ? { pathname, mod: await loader() } : undefined;
+}
+
+export async function renderMdxContent(url: string) {
+  return (await loadMdxModule(url))?.mod.default({});
+}
+
+export async function getMdxHead(url: string): Promise<Head | undefined> {
+  return (await loadMdxModule(url))?.mod.head;
+}
+
+function escapeUnsafeHtmlScriptTags(html: string) {
+  return html.replace(/<script/gi, "&lt;script").replace(/<\/script>/gi, "&lt;/script&gt;");
+}
+
+export async function renderMdx(url: string) {
+  const loaded = await loadMdxModule(url);
+  if (!loaded) return undefined;
+
+  return {
+    html: escapeUnsafeHtmlScriptTags(toHtml(loaded.mod.default({}))),
+    path: loaded.pathname,
+  };
+}
+
+export async function loadMdxHtml(path: string) {
+  const cached = getPrerenderedMdxHtml() ?? getClientPrerenderedMdxHtml(path);
+  if (cached) return raw(cached);
+  const content = await renderMdxContent(path);
+  return content ? raw(escapeUnsafeHtmlScriptTags(toHtml(content))) : null;
+}
+
+export function getMdxContent(path: string) {
+  const cached = getPrerenderedMdxHtml() ?? getClientPrerenderedMdxHtml(path);
+  return cached ? raw(cached) : undefined;
+}

package/src/docs/mdx/routes.ts

@@ -0,0 +1,121 @@
+import type { MdxModule } from "./types";
+import { metaFromDocument, textFromRawDocument, titleize } from "./document-text";
+import type { ContentMeta, ContentTreeNode, SearchDocument } from "./types";
+import { contentDir, mdxRawSources } from "./runtime-config";
+
+const allMdxModules = {
+  ...import.meta.glob("/src/pages/**/*.md"),
+  ...import.meta.glob("/src/pages/**/*.mdx"),
+} as Record<string, () => Promise<MdxModule>>;
+
+export const mdxModules = Object.fromEntries(
+  Object.entries(allMdxModules).filter(([filePath]) => filePath.startsWith(contentDir)),
+);
+
+export function filePathToRoutePath(filePath: string) {
+  const routePath = filePath
+    .replace(/^\/src\/pages/, "")
+    .replace(/\.mdx?$/, "")
+    .replace(/\/index$/, "")
+    .split("/")
+    .filter((segment) => !/^\(.+\)$/.test(segment))
+    .join("/");
+
+  return routePath || "/";
+}
+
+function insertTreeNode(tree: ContentTreeNode[], routePath: string, meta: ContentMeta) {
+  const segments = routePath.split("/").filter(Boolean);
+  let level = tree;
+
+  segments.forEach((segment, index) => {
+    const path = `/${segments.slice(0, index + 1).join("/")}`;
+    const isLeaf = index === segments.length - 1;
+    let node = level.find((item) => item.path === path || item.title === titleize(segment));
+
+    if (!node) {
+      node = {
+        title: isLeaf ? meta.title : titleize(segment),
+        path: isLeaf ? path : undefined,
+        type: isLeaf ? meta.type : "doc",
+        link: isLeaf ? meta.link : undefined,
+        external: isLeaf ? meta.external : undefined,
+        priority: isLeaf ? meta.priority : 0,
+        order: isLeaf ? meta.order : undefined,
+        description: isLeaf ? meta.description : undefined,
+        badge: isLeaf ? meta.badge : undefined,
+        children: [],
+      };
+      level.push(node);
+    }
+
+    if (isLeaf) {
+      node.title = meta.title;
+      node.path = path;
+      node.type = meta.type;
+      node.link = meta.link;
+      node.external = meta.external;
+      node.priority = meta.priority;
+      node.order = meta.order;
+      node.description = meta.description;
+      node.badge = meta.badge;
+    }
+
+    level = node.children;
+  });
+
+  const sort = (nodes: ContentTreeNode[]) => {
+    nodes.sort((a, b) => {
+      if (a.order !== undefined || b.order !== undefined)
+        return (a.order ?? 9999) - (b.order ?? 9999);
+      return b.priority - a.priority || a.title.localeCompare(b.title);
+    });
+    nodes.forEach((n) => sort(n.children));
+  };
+  sort(tree);
+}
+
+export const contentMeta = Object.fromEntries(
+  Object.entries(mdxModules).map(([filePath]) => {
+    const path = filePathToRoutePath(filePath);
+    return [path, metaFromDocument(filePath, mdxRawSources[path] ?? "")];
+  }),
+) as Record<string, ContentMeta>;
+
+export const mdxPages = new Map(
+  Object.entries(mdxModules)
+    .map(([filePath, loader]) => [filePathToRoutePath(filePath), loader] as const)
+    .filter(([path]) => contentMeta[path]?.type !== "link"),
+);
+
+export const contentTree = Object.entries(mdxModules).reduce<ContentTreeNode[]>(
+  (tree, [filePath]) => {
+    const routePath = filePathToRoutePath(filePath);
+    const meta = contentMeta[routePath];
+    if (meta.draft || meta.hidden) return tree;
+    insertTreeNode(tree, routePath, meta);
+    return tree;
+  },
+  [],
+);
+
+export const searchDocuments = Object.entries(mdxModules)
+  .map<SearchDocument | undefined>(([filePath]) => {
+    const path = filePathToRoutePath(filePath);
+    const meta = contentMeta[path];
+    if (meta.draft || meta.type === "link") return undefined;
+
+    return {
+      id: path,
+      title: meta.title,
+      path,
+      description: meta.description,
+      tags: meta.tags,
+      text: [meta.description, meta.tags.join(" "), textFromRawDocument(mdxRawSources[path] ?? "")]
+        .filter(Boolean)
+        .join(" "),
+    };
+  })
+  .filter((doc): doc is SearchDocument => Boolean(doc));
+
+export const mdxRoutes = [...mdxPages.keys()];

package/src/docs/mdx/runtime-config.ts

@@ -0,0 +1,15 @@
+import type { ResolvableHead as Head } from "unhead/types";
+
+declare const __IMPRENSA_CONTENT_DIR__: string;
+declare const __IMPRENSA_REPO__: string;
+declare const __IMPRENSA_REPO_BRANCH__: string;
+declare const __IMPRENSA_REPO_PATH__: string;
+declare const __IMPRENSA_RAW_SOURCES__: Record<string, string>;
+declare const __IMPRENSA_HEAD_DEFAULTS__: Head | null;
+
+export const contentDir = __IMPRENSA_CONTENT_DIR__;
+export const imprensaRepo = __IMPRENSA_REPO__;
+export const imprensaRepoBranch = __IMPRENSA_REPO_BRANCH__;
+export const imprensaRepoPath = __IMPRENSA_REPO_PATH__;
+export const mdxRawSources: Record<string, string> = __IMPRENSA_RAW_SOURCES__;
+export const headDefaults: Head | null = __IMPRENSA_HEAD_DEFAULTS__;

package/src/docs/mdx/source-links.ts

@@ -0,0 +1,56 @@
+import { filePathToRoutePath, mdxModules } from "./routes";
+import {
+  imprensaRepo,
+  imprensaRepoBranch,
+  imprensaRepoPath,
+  mdxRawSources,
+} from "./runtime-config";
+
+function routeToDistMarkdown(routePath: string) {
+  if (routePath === "/") return "/index.md";
+  return `${routePath}/index.md`;
+}
+
+function normalizeRepoUrl(repo: string) {
+  const trimmed = repo.trim();
+  if (!trimmed) return "";
+  if (/^https?:\/\//.test(trimmed)) return trimmed.replace(/\/$/, "");
+  return `https://${trimmed.replace(/\/$/, "")}`;
+}
+
+export function getMdxSourceForRoute(routePath: string) {
+  const normalized = routePath.replace(/\/$/, "") || "/";
+
+  for (const filePath of Object.keys(mdxModules)) {
+    if (filePathToRoutePath(filePath) !== normalized) continue;
+
+    const ext = filePath.match(/\.mdx?$/)?.[0] ?? ".mdx";
+    const sourceFile = filePath.replace(/^\//, "");
+
+    return {
+      routePath: normalized,
+      sourceFile,
+      markdownUrl: routeToDistMarkdown(normalized),
+      ext,
+    };
+  }
+
+  return undefined;
+}
+
+export function getDocLinks(routePath: string) {
+  const source = getMdxSourceForRoute(routePath);
+  if (!source) return undefined;
+
+  const repo = normalizeRepoUrl(imprensaRepo);
+  const branch = imprensaRepoBranch || "main";
+  const repoPath = (imprensaRepoPath ?? "").replace(/^\/+|\/+$/g, "");
+  const githubFile = repoPath ? `${repoPath}/${source.sourceFile}` : source.sourceFile;
+
+  return {
+    routePath: source.routePath,
+    markdownUrl: source.markdownUrl,
+    githubUrl: repo ? `${repo}/blob/${branch}/${githubFile}` : undefined,
+    rawMarkdown: mdxRawSources[source.routePath],
+  };
+}

package/src/docs/mdx/types.ts

@@ -0,0 +1,77 @@
+import type { RawHtml } from "ilha";
+import type { ResolvableHead as Head } from "unhead/types";
+
+export type MdxContent = string | RawHtml;
+
+export type MdxModule = {
+  default: (props: Record<string, string | number | boolean | undefined>) => MdxContent;
+  head?: Head;
+};
+
+export type PrerenderDataPayload = {
+  mdxHtml?: string;
+  mdxHtmlBase64?: string;
+  mdxPath?: string;
+};
+
+export type ContentPageType = "doc" | "custom" | "link";
+
+export type ContentMeta = {
+  title: string;
+  description?: string;
+  order?: number;
+  priority: number;
+  type: ContentPageType;
+  link?: string;
+  external?: boolean;
+  section?: string;
+  badge?: string;
+  draft?: boolean;
+  hidden?: boolean;
+  tags: string[];
+};
+
+export type ContentTreeNode = {
+  title: string;
+  path?: string;
+  type: ContentPageType;
+  link?: string;
+  external?: boolean;
+  priority: number;
+  order?: number;
+  description?: string;
+  badge?: string;
+  children: ContentTreeNode[];
+};
+
+export type SearchDocument = {
+  id: string;
+  title: string;
+  path: string;
+  text: string;
+  description?: string;
+  tags: string[];
+};
+
+export const articleClass = [
+  "flex-1 prose w-full max-w-none",
+  "text-areia-default",
+  "[--tw-prose-body:var(--areia-text-default)]",
+  "[--tw-prose-headings:var(--areia-text-strong)]",
+  "[--tw-prose-lead:var(--areia-text-subtle)]",
+  "[--tw-prose-links:var(--areia-primary)]",
+  "[--tw-prose-bold:var(--areia-text-strong)]",
+  "[--tw-prose-counters:var(--areia-text-muted)]",
+  "[--tw-prose-bullets:var(--areia-text-muted)]",
+  "[--tw-prose-hr:var(--areia-divider)]",
+  "[--tw-prose-quotes:var(--areia-text-strong)]",
+  "[--tw-prose-quote-borders:var(--areia-border)]",
+  "[--tw-prose-captions:var(--areia-text-muted)]",
+  "[--tw-prose-code:var(--areia-text-strong)]",
+  "[--tw-prose-pre-code:var(--areia-text-default)]",
+  "[--tw-prose-pre-bg:var(--areia-surface-muted)]",
+  "[--tw-prose-th-borders:var(--areia-border)]",
+  "[--tw-prose-td-borders:var(--areia-divider)]",
+  "prose-a:underline-offset-4",
+  "prose-code:before:content-none prose-code:after:content-none",
+].join(" ");

package/src/docs/mdx.ts

@@ -0,0 +1,20 @@
+export {
+  articleClass,
+  contentMeta,
+  contentTree,
+  getClientPrerenderedMdxHtml,
+  getDocLinks,
+  getMdxContent,
+  getMdxHead,
+  getMdxSourceForRoute,
+  getPrerenderedMdxHtml,
+  headDefaults,
+  loadMdxHtml,
+  mdxRoutes,
+  renderMdx,
+  renderMdxContent,
+  searchDocuments,
+  setPrerenderedMdxHtml,
+} from "./mdx/index";
+
+export type { ContentMeta, ContentPageType, ContentTreeNode, SearchDocument } from "./mdx/index";